{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "强化学习算法的模式都比较固定，一般包括sample（即训练时采样动作），predict（测试时预测动作），update（算法更新）以及保存模型和加载模型等几个方法，其中对于每种算法samle和update的方式是不相同，而其他方法就大同小异。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "from collections import defaultdict\n",
    "\n",
    "class QLearning(object):\n",
    "    def __init__(self,n_states,\n",
    "                 n_actions,cfg):\n",
    "        self.n_actions = n_actions \n",
    "        self.lr = cfg.lr  # 学习率\n",
    "        self.gamma = cfg.gamma  \n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.sample_count = 0  \n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.Q_table  = defaultdict(lambda: np.zeros(n_actions)) # 用嵌套字典存放状态->动作->状态-动作值（Q值）的映射，即Q表\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作，训练时用\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的，这里选择指数递减\n",
    "        # e-greedy 策略\n",
    "        if np.random.uniform(0, 1) > self.epsilon:\n",
    "            action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作\n",
    "        else:\n",
    "            action = np.random.choice(self.n_actions) # 随机选择动作\n",
    "        return action\n",
    "    def predict_action(self,state):\n",
    "        ''' 预测或选择动作，测试时用\n",
    "        '''\n",
    "        action = np.argmax(self.Q_table[str(state)])\n",
    "        return action\n",
    "    def update(self, state, action, reward, next_state, terminated):\n",
    "        Q_predict = self.Q_table[str(state)][action] \n",
    "        if terminated: # 终止状态\n",
    "            Q_target = reward  \n",
    "        else:\n",
    "            Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) \n",
    "        self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练\n",
    "强化学习算法的训练方式也比较固定，如下：\n",
    "```python\n",
    "for i_ep in range(train_eps): # 遍历每个回合\n",
    "    state = env.reset()  # 重置环境,即开始新的回合\n",
    "    while True: # 对于一些比较复杂的游戏可以设置每回合最大的步长，例如while ep_step<100，就是每回合最大步长为100。\n",
    "        action = agent.sample(state)  # 根据算法采样一个动作\n",
    "        next_state, reward, terminated, _ = env.step(action)  # 与环境进行一次动作交互\n",
    "        agent.memory.push(state, action, reward, next_state, terminated) # 记录memory\n",
    "        agent.update(state, action, reward, next_state, terminated)  # 算法更新\n",
    "        state = next_state  # 更新状态\n",
    "        if terminated:\n",
    "            break\n",
    "```\n",
    "首先对于每个回合，回合开始时环境需要重置，好比我们每次开一把游戏需要从头再来一样。我们可以设置智能体在每回合数的最大步长，尤其是对于比较复杂的游戏，这样做的好处之一就是帮助智能体在训练中快速收敛，比如我们先验地知道最优解的大概步数，那么理论上智能体收敛时也应该是这个步数附近，设置最大步数可以方便智能体接近这个最优解。在每个回合中，智能体首先需要采样（sample），或者说采用探索策略例如常见的$\\varepsilon$-greedy策略或者UCB探索策略等等。采样的过程是将当前的状态state作为输入，智能体采样输出动作action。然后环境根据采样出来的动作反馈出下一个状态以及相应的reward等信息。接下来对于具有memory的智能体例如包含replay memory的DQN来说，需要将相应的transition（记住这个词，中文不好翻译，通常是状态、动作、奖励等信息）。紧接着就是智能体更新，对于深度强化学习此时一般从memory中随机采样一些transition进行更新，对于Q learning一般是采样上一次的transition。更新公式是比较关键的部分，但是也很通用，一般基于值的算法更新公式都是一个套路如下：\n",
    "$$\n",
    "y_{j}= \\begin{cases}r_{j} & \\text { for terminal } s_{t+1} \\\\ r_{j}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{t+1}, a^{\\prime} ; \\theta\\right) & \\text { for non-terminal } s_{t+1}\\end{cases}\n",
    "$$\n",
    "智能体更新完之后，通常需要更新状态，即```state = next_state```，然后会检查是否完成了这一回合的游戏，即```terminated==True```，注意完成并不代表这回合成功，也有可能是失败的太离谱，等同学们有了自定义强化学习环境的经验就知道了（等你长大就知道了XD）。\n",
    "如果需要记录奖励、损失等等的话可以再加上，如下方代码，实际项目中更多地使用tensorboard来记录相应的数据，甚至于笔者就在这些教学代码中使用过，但是看起来有些繁琐，容易给大家增加不必要的学习难度，因此学有余力以及需要在项目研究中做强化学习的可以去看看，也很简单。\n",
    "此外稍微复杂一些的强化学习不是一次性写完代码就能收敛的，这时需要我们做一个调参侠。为了检查我们参数调得好不好，可以在终端print出奖励、损失以及epsilon等随着回合数的变化，这点说明一下强化学习的训练过程一般都是先探索然后收敛的，官方的话就是权衡exploration and exploitation。e-greedy策略的做法就是前期探索，然后逐渐减小探索率至慢慢收敛，也就是这个epsilon。这个值越大比如0.9就说明智能体90%的概率在随机探索，通常情况下会设置三个值，epsilon_start、epsilon_end以及epsilon_decay，即初始值、终止值和衰减率，其中初始值一般是0.95不变，终止值是0.01，也就是说即使在收敛阶段也让智能体保持很小概率的探索，这样做的原因就是智能体已经学出了一个不错的策略，但是保不齐还有更好的策略，好比我们知道要出人头地学历高比较重要，但是“人还是要有梦想的，万一实现了呢”，总是存在意外的可能，对吧。回归正题，比较关键的是epsilon_decay这个衰减率，这个epsilon衰减太快了学来的策略往往过拟合，好比一条只能选择一朵花的花道上，你早早选择了一朵看起来还可以的花，却错过了后面更多的好花。但是衰减的太慢会影响收敛的速度，好比你走过了花道的尽头也还没选出一朵花来，相比前者不如更甚。当然强化学习的调参相比于深度学习只能说是有过之无不及，比较复杂，不止epsilon这一个，这就需要同学们的耐心学习了。\n",
    "强化学习测试的代码跟训练基本上是一样的，因此我放到同一个代码段里。相比于训练代码，测试代码主要有以下几点不同：1、测试模型的过程是不需要更新的，这个是不言而喻的；2、测试代码不需要采样（sample）动作，相比之代替的是预测（sample）动作，其区别就是采样动作时可能会使用各种策略例如$\\varepsilon$-greedy策略，而预测动作不需要，只需要根据训练时学习好的Q表或者网络模型代入状态得到动作即可；3、测试过程终端一般只需要看奖励，不需要看epislon等，反正它在测试中也是无意义的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg,env,agent):\n",
    "    print('开始训练！')\n",
    "    print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}')\n",
    "    # print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n",
    "    rewards = []  # 记录奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录每个回合的奖励\n",
    "        state = env.reset(seed=cfg.seed)  # 重置环境,即开始新的回合\n",
    "        while True:\n",
    "            action = agent.sample_action(state)  # 根据算法采样一个动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 与环境进行一次动作交互\n",
    "            agent.update(state, action, reward, next_state, terminated)  # Q学习算法更新\n",
    "            state = next_state  # 更新状态\n",
    "            ep_reward += reward\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep+1)%20==0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.1f}，Epsilon：{agent.epsilon:.3f}\")\n",
    "    print('完成训练！')\n",
    "    return {\"rewards\":rewards}\n",
    "def test(cfg,env,agent):\n",
    "    print('开始测试！')\n",
    "    print(f'环境：{cfg.env_name}, 算法：{cfg.algo_name}')\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录每个episode的reward\n",
    "        state = env.reset(seed=cfg.seed)  # 重置环境, 重新开一局（即开始新的一个回合）\n",
    "        while True:\n",
    "            action = agent.predict_action(state)  # 根据算法选择一个动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 与环境进行一个交互\n",
    "            state = next_state  # 更新状态\n",
    "            ep_reward += reward\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合数：{i_ep+1}/{cfg.test_eps}, 奖励：{ep_reward:.1f}\")\n",
    "    print('完成测试！')\n",
    "    return {\"rewards\":rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3、定义环境\n",
    "\n",
    "OpenAI Gym中其实集成了很多强化学习环境，足够大家学习了，但是在做强化学习的应用中免不了要自己创建环境，比如在本项目中其实不太好找到Qlearning能学出来的环境，Qlearning实在是太弱了，需要足够简单的环境才行，因此本项目写了一个环境，大家感兴趣的话可以看一下，一般环境接口最关键的部分即使reset和step。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import turtle\n",
    "import numpy as np\n",
    "\n",
    "# turtle tutorial : https://docs.python.org/3.3/library/turtle.html\n",
    "\n",
    "class CliffWalkingWapper(gym.Wrapper):\n",
    "    def __init__(self, env):\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        self.t = None\n",
    "        self.unit = 50\n",
    "        self.max_x = 12\n",
    "        self.max_y = 4\n",
    "\n",
    "    def draw_x_line(self, y, x0, x1, color='gray'):\n",
    "        assert x1 > x0\n",
    "        self.t.color(color)\n",
    "        self.t.setheading(0)\n",
    "        self.t.up()\n",
    "        self.t.goto(x0, y)\n",
    "        self.t.down()\n",
    "        self.t.forward(x1 - x0)\n",
    "\n",
    "    def draw_y_line(self, x, y0, y1, color='gray'):\n",
    "        assert y1 > y0\n",
    "        self.t.color(color)\n",
    "        self.t.setheading(90)\n",
    "        self.t.up()\n",
    "        self.t.goto(x, y0)\n",
    "        self.t.down()\n",
    "        self.t.forward(y1 - y0)\n",
    "\n",
    "    def draw_box(self, x, y, fillcolor='', line_color='gray'):\n",
    "        self.t.up()\n",
    "        self.t.goto(x * self.unit, y * self.unit)\n",
    "        self.t.color(line_color)\n",
    "        self.t.fillcolor(fillcolor)\n",
    "        self.t.setheading(90)\n",
    "        self.t.down()\n",
    "        self.t.begin_fill()\n",
    "        for i in range(4):\n",
    "            self.t.forward(self.unit)\n",
    "            self.t.right(90)\n",
    "        self.t.end_fill()\n",
    "\n",
    "    def move_player(self, x, y):\n",
    "        self.t.up()\n",
    "        self.t.setheading(90)\n",
    "        self.t.fillcolor('red')\n",
    "        self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n",
    "\n",
    "    def render(self):\n",
    "        if self.t == None:\n",
    "            self.t = turtle.Turtle()\n",
    "            self.wn = turtle.Screen()\n",
    "            self.wn.setup(self.unit * self.max_x + 100,\n",
    "                          self.unit * self.max_y + 100)\n",
    "            self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n",
    "                                        self.unit * self.max_y)\n",
    "            self.t.shape('circle')\n",
    "            self.t.width(2)\n",
    "            self.t.speed(0)\n",
    "            self.t.color('gray')\n",
    "            for _ in range(2):\n",
    "                self.t.forward(self.max_x * self.unit)\n",
    "                self.t.left(90)\n",
    "                self.t.forward(self.max_y * self.unit)\n",
    "                self.t.left(90)\n",
    "            for i in range(1, self.max_y):\n",
    "                self.draw_x_line(\n",
    "                    y=i * self.unit, x0=0, x1=self.max_x * self.unit)\n",
    "            for i in range(1, self.max_x):\n",
    "                self.draw_y_line(\n",
    "                    x=i * self.unit, y0=0, y1=self.max_y * self.unit)\n",
    "\n",
    "            for i in range(1, self.max_x - 1):\n",
    "                self.draw_box(i, 0, 'black')\n",
    "            self.draw_box(self.max_x - 1, 0, 'yellow')\n",
    "            self.t.shape('turtle')\n",
    "\n",
    "        x_pos = self.s % self.max_x\n",
    "        y_pos = self.max_y - 1 - int(self.s / self.max_x)\n",
    "        self.move_player(x_pos, y_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "def env_agent_config(cfg,seed=1):\n",
    "    '''创建环境和智能体\n",
    "    '''    \n",
    "    env = gym.make(cfg.env_name,new_step_api=True)  \n",
    "    env = CliffWalkingWapper(env)\n",
    "    n_states = env.observation_space.n # 状态维度\n",
    "    n_actions = env.action_space.n # 动作维度\n",
    "    agent = QLearning(n_states,n_actions,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数\n",
    "\n",
    "到这里所有qlearning模块就算完成了，下面需要设置一些参数，方便大家“炼丹”，其中默认的是笔者已经调好的～。另外为了定义了一个画图函数，用来描述奖励的变化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    '''配置参数\n",
    "    '''\n",
    "    def __init__(self):\n",
    "        self.env_name = 'CliffWalking-v0' # 环境名称\n",
    "        self.algo_name = 'Q-Learning' # 算法名称\n",
    "        self.train_eps = 400 # 训练回合数\n",
    "        self.test_eps = 20 # 测试回合数\n",
    "        self.max_steps = 200 # 每个回合最大步数\n",
    "        self.epsilon_start = 0.95 #  e-greedy策略中epsilon的初始值\n",
    "        self.epsilon_end = 0.01 #  e-greedy策略中epsilon的最终值\n",
    "        self.epsilon_decay = 300 #  e-greedy策略中epsilon的衰减率\n",
    "        self.gamma = 0.9 # 折扣因子\n",
    "        self.lr = 0.1 # 学习率\n",
    "        self.seed = 1 # 随机种子\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线\n",
    "    '''\n",
    "    last = data[0]  # First value in the plot (first timestep)\n",
    "    smoothed = list()\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,title=\"learning curve\"):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{title}\")\n",
    "    plt.xlim(0, len(rewards))  # 设置x轴的范围\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、我准备好了！\n",
    "\n",
    "到现在我们真的可以像海绵宝宝那样大声说出来“我准备好了！“，跟着注释来看下效果吧～。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/curiousx/miniconda3/lib/python3.11/site-packages/gym/core.py:317: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n",
      "  deprecation(\n",
      "/Users/curiousx/miniconda3/lib/python3.11/site-packages/gym/utils/passive_env_checker.py:241: DeprecationWarning: `np.bool8` is a deprecated alias for `np.bool_`.  (Deprecated NumPy 1.24)\n",
      "  if not isinstance(terminated, (bool, np.bool8)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练！\n",
      "环境:CliffWalking-v0, 算法:Q-Learning\n",
      "回合：20/400，奖励：-68.0，Epsilon：0.010\n",
      "回合：40/400，奖励：-40.0，Epsilon：0.010\n",
      "回合：60/400，奖励：-25.0，Epsilon：0.010\n",
      "回合：80/400，奖励：-27.0，Epsilon：0.010\n",
      "回合：100/400，奖励：-55.0，Epsilon：0.010\n",
      "回合：120/400，奖励：-26.0，Epsilon：0.010\n",
      "回合：140/400，奖励：-27.0，Epsilon：0.010\n",
      "回合：160/400，奖励：-15.0，Epsilon：0.010\n",
      "回合：180/400，奖励：-24.0，Epsilon：0.010\n",
      "回合：200/400，奖励：-21.0，Epsilon：0.010\n",
      "回合：220/400，奖励：-22.0，Epsilon：0.010\n",
      "回合：240/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：260/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：280/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：300/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：320/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：340/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：360/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：380/400，奖励：-13.0，Epsilon：0.010\n",
      "回合：400/400，奖励：-13.0，Epsilon：0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "环境：CliffWalking-v0, 算法：Q-Learning\n",
      "回合数：1/20, 奖励：-13.0\n",
      "回合数：2/20, 奖励：-13.0\n",
      "回合数：3/20, 奖励：-13.0\n",
      "回合数：4/20, 奖励：-13.0\n",
      "回合数：5/20, 奖励：-13.0\n",
      "回合数：6/20, 奖励：-13.0\n",
      "回合数：7/20, 奖励：-13.0\n",
      "回合数：8/20, 奖励：-13.0\n",
      "回合数：9/20, 奖励：-13.0\n",
      "回合数：10/20, 奖励：-13.0\n",
      "回合数：11/20, 奖励：-13.0\n",
      "回合数：12/20, 奖励：-13.0\n",
      "回合数：13/20, 奖励：-13.0\n",
      "回合数：14/20, 奖励：-13.0\n",
      "回合数：15/20, 奖励：-13.0\n",
      "回合数：16/20, 奖励：-13.0\n",
      "回合数：17/20, 奖励：-13.0\n",
      "回合数：18/20, 奖励：-13.0\n",
      "回合数：19/20, 奖励：-13.0\n",
      "回合数：20/20, 奖励：-13.0\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHJCAYAAAB+GsZPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5rElEQVR4nO3dd3hUVeLG8e+dlt5DEnrvvRMpIrLI2n+srq6IFbuiYgFX7FhWEAUUURF7WxUrWNayKi5dBKVIlSZJgCSE9MzM/f0xyTCTQoopkHk/z8ND5t47954z9Z1zzj3XME3TRERERES8LA1dABEREZHjjQKSiIiISCkKSCIiIiKlKCCJiIiIlKKAJCIiIlKKApKIiIhIKQpIIiIiIqUoIImIiIiUooAkNaY5RkVEpLFSQJIa+frrr5kyZUqt7GvRokV07tyZvXv31ul9pKyUlBTGjx9Pz549SU5OJi8vr8Jt9+zZw8MPP8yYMWPo1asXw4YN49prr2Xp0qVVPl7nzp2ZO3dubRS9Ts2dO5fOnTvXy7GcTidTp06lb9++9OvXj+XLl9fJcbKysnj66ac566yz6Nu3L8nJyVx66aV88803fttNnTqVUaNGeW+PGjWKqVOnem8vX76c0047jR49ejBx4kSys7O59tpr6d27NwMHDmTw4MHcdNNNZY7/4osv0rlzZyZOnFhm3cKFC+ncuTP79++vUl18y7R37146d+7MokWLKtx+woQJTJgwoUr7ri+7du3i2muvZcCAAQwePJj77ruP7Ozshi6W+LA1dAHkxPTyyy/X2r5GjhzJO++8Q0JCQp3eR8p65ZVX+Pnnn5kxYwaJiYmEhISUu93SpUu55ZZbSEhI4IorrqBdu3akp6fz6aefcuWVV3LppZfyz3/+s55LX3fOP/98hg8fXi/H+uGHH/jggw+4/vrrOemkk+jWrVutH2P79u1cddVVuN1uLrnkErp06UJubi6ffPIJ1113HTfffDPXX399ufd9+umnCQ8P995+/PHHcbvdPP/888TFxfHhhx/y7bffcu+999KxY0fefvttVq5cWW49o6OjWbVqFQUFBQQFBXnXrVq1inbt2tG0adNarzvAfffdVyf7ramsrCwuvfRS4uPjeeyxx0hPT2fGjBns3buXF198saGLJ8UUkKTBxcbGEhsbW+f3kbIyMzNJSEjg9NNPr3Cb1NRUJk+eTK9evXj22Wf9vtjGjh3Lyy+/zKOPPkrHjh05//zz66PYdS4pKYmkpKR6OVZmZiYA48aNo2XLlrW+/6KiIm655RbsdjtvvvkmcXFx3nWjR4/mnnvuYfbs2YwaNYouXbqUuX/pwJaZmcnAgQM56aSTAPjPf/4DwEUXXYRhGOzatYvFixezZ88eb33y8vJYs2YNN910E0888QQrV670BlDTNPnpp58466yzar3uJTp06FBn+66Jt956i8zMTBYtWuT9HEtMTOTqq69mzZo19O/fv4FLKKAuNqmBCRMmsHLlSlauXEnnzp1ZsWIFK1asoHPnzrz99tuccsop9OvXjx9//BGAd999l3HjxtGnTx969erFOeecw2effebdX+nusqlTp3LZZZfx/vvve5vyzznnHL7//vs/dR+AtWvXMn78ePr06cPIkSN55ZVXuOyyy/y6EMrz888/c8UVV9CvXz+GDBnC5MmTSU1NLbcsJUp3TXTu3Jmnn36acePG0atXL55++mm6du3K66+/7ne/9PR0unfv7m2lK/m1/pe//IUePXpw2mmn8dprr1X6PB05coRHH32U0aNH07NnT84880zee+89v/ItWrSIP/7445hdX2+++SY5OTk8/PDDfuGoxGWXXUafPn149tlna21c2rvvvssZZ5xBjx49GDlyJHPnzsXlcpXZprLXVbdu3Xj33XcZOnQogwYNYtu2bUyYMIG7776b559/npEjR9KzZ08uvPBC1q9f771v6S62qtwH4L///a/3+T3ttNP49NNP+ctf/lLhYzt16lTva2T06NHebqCCggKeeeYZxo4dS8+ePRkzZgzPP/88brfbr0y33347kyZNok+fPlx++eXlHuO7775jy5Yt3HzzzX7hqMSkSZO4+OKLcTqd5d6/5HVc0pW1b98+PvzwQzp37syECRO8devSpQtTp04lOTkZgDVr1nj3sWLFCoqKijjvvPNo2bKlX7fs1q1byczM9Aau9PR0HnjgAU455RR69OjBoEGDuOGGG6rcnW6aJnfddRe9evXyHqd0F1vnzp154403uPvuuxk0aBB9+/bl5ptv5uDBg377evHFFzn11FPp1asXF154Id988433M68iV1xxBePGjSuz/Prrr+fss88GPC2y/fv39/uRN2zYMMLCwsp8ZknDUUCSarvvvvvo1q0b3bp145133qF79+7edU8//TRTpkzh3nvvpW/fvrzxxhvce++9jB49mueee46ZM2ficDi4/fbbSUlJqfAYv/76Ky+++CKTJk3imWeewWq1ctNNN3H48OEa32f79u1cdtllAMyaNYubbrqJ559/3u+DvDwbN27k4osvpqCggMcff5wHHniAX3/9lSuvvLLCL5WKzJ8/n7POOos5c+Zw2mmnMWjQIBYvXuy3zeeff45pmpxxxhkA3H///cyZM4ezzz6b+fPnM3bsWB555BGeeeaZCo+Tn5/PRRddxCeffMLEiROZN28e/fv35+6772b+/PmA57k6+eSTadKkCe+8806FrT/ffPMN3bt3P2b3x1//+lf27dvHxo0bq/V4lOe5557jnnvuITk5mfnz5zN+/HheeOEF7rnnHu82VX1duVwuFi5cyMMPP8xdd91F+/btAfjiiy/4+uuvmTZtGrNmzeLgwYPcdNNNZUKYr8rus3z5cq6//nqaNm3K3LlzGT9+PPfdd98xx9Vcf/31XHfddYDn+bjvvvswTZNrr72WBQsWcP7553uf86eeeqpMV9Fnn31GWFgYzz77bLljewC+//57rFYrJ598crnrmzRpwj333EOPHj0qLCdAQkIC77zzDk2aNOHkk0/mnXfe4e677+a8884D4J133uH666+nRYsWtGzZkp9++sl736VLl9KtWzdiY2MZNmwYP/zwg3fdqlWrsNvtDB48GNM0ueaaa/jxxx+5/fbbefHFF7nxxhtZtmxZlbvJpk+fzqeffsrTTz/NsGHDKtzuySefxO12M2vWLO68806+/fZbHnnkEe/6p59+mpkzZ/LXv/6VefPm0bt3b2655ZZKj3/22WezYcMGdu3a5V2WlZXF999/zznnnAN4Povatm3rdz+r1UqLFi3YuXNnleopdU9dbFJtHTp08I5J6NOnj9+6iy66iLFjx3pv79mzhyuvvNJvfEPz5s0ZN24ca9as8YaA0o4cOcKiRYto1aoVAKGhoVx88cXeAaI1uc9zzz1HREQECxYs8I61adeuHRdeeOEx6zt//nyio6NZuHChtwUlISGB2267ja1btx7zvqUNGDDA75f+Oeecwz//+U/++OMPmjVrBsDixYs56aSTaNKkCTt37uTf//43kydP5uqrrwY8vzQNw+C5557joosuIiYmpsxxFi1axJYtW3j77bfp27cvAMOHD8fpdDJv3jwuvPBC7xeWw+Eo8zz62rdvX4VfriVat27t3dY3MFfXkSNHmDdvHhdccAHTpk0DPPWNjo5m2rRpXH755XTs2LFar6trr72WkSNH+h3H6XTy4osvel/HOTk5TJkyhU2bNlUYFCq7z9y5c+nYsSNPP/00hmEAEBcXx+TJkyusb6tWrbyv165du9KiRQu+++47/ve//zFr1ixvPYYOHUpwcDCzZ8/mkksuoWPHjgDY7XYeeOABHA5HhcdISUkhJiaGsLCwCrepipLXicPhIDY21vuaKemK9H0NJScns3btWu/tH374wfu5MGzYMN566y3va3716tX07t2bsLAwUlNTCQkJYcqUKQwYMACAwYMHs3v3bt55551Ky/jEE0/wzjvv8PTTTzNixIhjbtupUyceffRR7+3169fz+eefA5Cbm8sLL7zA+PHjuf32273lzsvLq7QcY8aM4YEHHuDTTz/lhhtuAODLL7/E5XJx5plnAp7XeXnPR1hYmAZqH0fUgiS1qmvXrn63p06dyu23305WVhY///wzH330EW+88QYAhYWFFe4nNjbW+8UBRz+Ej3WWVWX3Wb58OSNGjPAbiNy3b1+aN29+zDqtWbOGESNG+HUv9e3bl2+++aZMfStTevsxY8YQFBTEkiVLANi/fz9r1qzx/tJcvnw5pmkyatQonE6n99+oUaMoKCiosPVr5cqVNG/e3BuOSpx99tkUFBSwbt26apW7MhaL56PE5XJhmqZfWZ1OZ5W73tauXUt+fn659QW83bbVeV2V9xz5hnzwjP+AY7++jnWfwsJC1q5dy5gxY7zhCDxjtGy26v0OXblyJTabze+HBuDtnvEdAN2uXbtjhiPwtEwcq2WsLiQnJ7N161aysrLYs2cPv//+u7c1Z8iQIdhsNv73v/8BsHr1am/3WmJiIq+++ir9+/dn7969/Pjjj7z22mv89NNPx/y8AE+r4vPPP88ZZ5xRJhCXp/SPgqSkJO/z//PPP5Ofn1/mOSgJOCXKe52HhoYyevRo73saPD96kpOTva+ZY70ffF8/0rDUgiS1KjQ01O/27t27uffee1m2bBl2u5127dp5B4Ie60Oi9NlUJR8avmMwqnuf9PT0csdgxMfHV7hP8AxKLe9+NVH68QkPD2f06NEsXryYiRMnsmTJEkJCQhg9erT32ECFLW0l46BKO3z4ME2aNCmzvKSuWVlZVS5z8+bNKx3/sWfPHu+2K1eu5JJLLvFb/+qrrzJ48OBKj1VS35LWstLS0tKA6r2uSj/mUPa1UhLwqvP68r1PZmYmLperzOvEarUSHR1d4T7Lc/jwYWJiYrBarX7LS57PI0eOeJdVpVWoefPm/Pe//yUnJ6fC7VNSUmp1UPqQIUMAT+Ddt28fYWFh3kASHh5Or169WLFiBYMHDyYtLc2vK+zjjz9m1qxZ7N+/n+joaLp27UpwcHClx9y8eTPDhg3j008/5dJLL630bMDyns+S1056ejpAmRNBfJ/fvXv3cuqpp/qtf/TRRxk3bhznnHMOH3/8MZs3byY+Pp4VK1b4dd+Fh4eTk5NTpkzZ2dneECUNTwFJ6ozb7ebqq6/Gbrfz3nvv0bVrV2w2G9u2beOjjz6q9/IkJSWVGYQJcOjQIdq1a1fh/SIiIrwfmL6+++47unbtWmF4K+8DsDxnn302V199tffsn9NOO8374R0ZGQl4Tscv78utpFuutKioKL8xECUOHDgAUG63XEVGjRrFCy+8wL59+/xa23799Vdvd9QXX3xBXFwc3bt3Jy8vz28wOFBmvEVFSuo7c+ZM2rRpU2Z9fHz8cfe6As8Xp91uL/P6KglP1REVFUVGRgYul8svJJWEw+o8d+DpGnrttdf8url8paenc+qpp3LRRRdx9913V2vfFYmNjaVz586sW7eObdu2MWTIEOx2u3f90KFDWbRoEStXriQyMtL7Olq9ejVTpkxhwoQJXHnlld6w8Pjjj1c6VvDmm2/mkksu4YwzzmDatGm8++67ZUJmVZWExdKfDb6fAwkJCWVe5y1atAA8LWhNmjThs88+o0mTJgQFBTFmzBjvdm3btmX37t1+93W5XOzdu9dvO2lY6mKTGin59XwsGRkZ7Ny5k/POO4+ePXt6uxpKztI41q/1ujBw4EB++OEHCgoKvMs2btxYaevIgAED+PHHH/2a+Ddu3MjVV1/Nhg0bvN0uvoODt2/fXuUvxmHDhhEfH8+rr77Khg0bvN1rJccGz2PZs2dP77/09HRmz55d4TEGDhzIvn37/MaBgOfXud1up1evXlUqG8DFF19MREQEd999t/ex++OPP7jwwgu54IILmDt3LitXruS6667DarUSHh7uV9aePXv6dU0dS+/evbHb7aSmpvrd32azMWvWLPbu3Xvcva7A01LUr18/vv76a7/l33zzTbUH8g8aNAin0+kdD1Pi448/Bqj2KeDDhg2jU6dOPPnkk2RkZJRZ/8QTT+B0Omv9NPuTTjqJ9evXs3r16jKDpYcNG8a+ffv47rvvGDJkiDfIrF27FrfbzU033eQNRy6Xy9sdd6znNj4+nuDgYO699142bNjASy+9VOOyd+nShYiICO8UBiW+/PJL798Oh6PM67wkvFqtVs466yy+/fZbPv/8c0aPHu3Xkjl06FBWrVrlF7iWLl1Kbm4uQ4cOrXG5pXapBUlqJDIykrVr17Js2bIKm7Lj4uJo3rw5b7zxBklJSURGRvLDDz/w6quvAsce71EXrr32WpYsWcLEiRO54ooryMrKYvbs2VgslmP2+19//fVccMEFXHPNNVxyySXk5+fz1FNP0atXL4YOHUp+fj7BwcE89thj3HzzzeTk5DBnzpwqd61YrVbOOOMMXn/9dRITE/26ojp37szZZ5/NPffcw759++jRowc7d+7kySefpEWLFuW2soBnTp0333yTG264gUmTJtGiRQu++eYb3n//fW688UZvS01VNGnShNmzZzNp0iTGjRvHhAkTaN++PdOmTePRRx/l559/pl27dlxwwQVV2t/PP/9c7kSjw4cPp3379kycOJHZs2eTnZ3N4MGDSU1NZfbs2RiG4f3iOp5eVyUmTZrEhAkTmDRpEueddx5//PEHs2fPBqo3rmTEiBEMHjyYadOmkZqaSpcuXVi5ciUvvPAC//d//1ftOX1sNhuPP/44V1xxBX/729+8E0Wmp6ezaNEifvjhB2677bZqheaqGDJkCK+99hpFRUVlJt3s2bMnUVFRfPPNN97B+IC3DA8++CB/+9vfOHz4MG+88QabN28GPIOnKwvbJ598MmPHjmXu3LmcdtppNZpbKjw8nIkTJzJnzhxCQkIYNGgQK1eu5K233gKq9gPxnHPOYeHChVgsFl544QW/dRdddBGvv/46l19+OTfeeCOZmZnMmDGDESNG0K9fv2qXV+qGWpCkRsaPH4/dbueqq6465rwd8+bNIzExkalTp3LLLbewbt06nn32Wdq1a8fq1avrscSeM61efPFFCgoKmDRpEk8++SRXXXUVTZo0OeZYjm7duvHaa6/hdDq55ZZbmD59Ov379+e5557D4XAQGRnpnafnhhtuYPbs2dxwww2Vnjbt65xzzvGe5VL6w/fRRx/l8ssv5+2332bixInMnz+f008/nYULF1bYhRASEsJrr73GKaecwuzZs7nuuutYs2YNDz/8cLmXgajMkCFD+PDDDznppJNYuHAhV155JXPmzGHgwIFMnTqV/Px8zjrrLO8v/WNZunQpjz76aJl/v/76KwC33HILU6dO5T//+Q9XXXUVM2bMoH///rz++utEREQAx9frqsSAAQOYO3cuO3fu5Prrr+ell17yTk1QnTPISs5QvPDCC3n55Ze5+uqr+fzzz5k8ebLfOJbq6Nq1K++99x6jRo3irbfe4tprr2X69Om4XC4WLFhQ4ZivP2PgwIGA531XOqRYrVaGDBlCUVGRX4vJ4MGDuffee1m7di1XXXUVjz32GM2aNePpp58GqLSbrcQ///lPbDab39QQ1XXNNddw00038dFHH3HNNdewevVq7xlt5Y1rK61Lly506tSJuLg479xQJWJjY3n11VeJiYnh9ttv58knn2Ts2LE8+eSTNS6v1D7D1BVHJUCUDOgt6bYCz2Dlk046iTvvvLPMwGKpupycHN555x369+9P7969G7o4DeLrr78mKSnJb5qDrVu3cuaZZzJv3rwyA3rl+OV0Ovn0008ZPHiw3/xfb7zxBtOnT2fFihXVaoWVE5O62CRgbNiwgTlz5jB58mS6d+9OZmYmL730EhEREWVO35XqCQsL44orrmjoYjSopUuXsmTJEm6//Xbatm1Lamqqt1XrWBMWyvHHZrPxwgsv8Morr3DdddcRExPDli1beOqppzj33HMVjgKEWpAkYLjdbubPn89HH33E/v37CQ0NZdCgQdx2223eiQ5Faio/P5/Zs2fzxRdfkJaWRnR0NMOHD+e2226rdCoJOf7s2bOHWbNmsWLFCrKysmjWrBlnn30211xzjd8ZedJ4KSCJiIiIlKJB2iIiIiKlKCCJiIiIlKKAJCIiIlKKApKIiIhIKTrNv5hpmrjdgTde3WIxVO8AonoHFtU7sARivS0Wo1oz1VeHAlIxwzDIysrF6az/6zg1FJvNQkxMmOodIFRv1TsQqN6BVe/Y2DCs1roJSOpiExERESlFAUlERESkFAUkERERkVIUkERERERKUUASERERKUUBSURERKQUBSQRERGRUhSQREREREpRQBIREREp5YQNSG63mzlz5jB8+HD69OnDVVddxZ49exq6WCIiItIInLABad68ebz55ps89NBDvP3227jdbiZOnEhhYWFDF01EREROcCdkQCosLGThwoVMmjSJkSNH0qVLF5588klSUlL48ssvG7p4IiIicoI7IS9Wu3nzZnJyckhOTvYui4yMpFu3bqxatYozzzyzRvu1Wk/IvFhjJfVVvQOD6q16BwLVO7DqbdTNdWqBEzQgpaSkANC0aVO/5QkJCd51NREZGfKnynWiCpR6HzqcR0xEMBaL5x3VGOqdm1+E3WbBbrNWuu3v+7P4IyOPLq1jK91234Fs/jiQzYCuiQB8sXwXdpuFU/q39D5+AKZpsn7rQX7dcYizhrcjMszhXVfkdPHN6j20bRZFp1YxABQUuVi2/g86tY6hWXx4ucd2uU0yj+STX+gi9VAuHVpG++3XNE2W/LiT2Khg+nZKYOPv6XRvF4fL5cblNgkLtgOQmp5LTEQQwUE2XG4TJwaxMWEUOd2s23oAu9VCr47x7Pwjix/X/0GvDvH07tiEAxl5rN6UgtuEIT2SiIsK4dDhPNZtPcDAbkkcySnEZrWQEBvqV+6VG1PYm5rN6EGt2JWSxeHsAkKD7XRqGU2Ry82ib7dhtRic1KsZQXYrW/dkckr/FuQVOPnPyt3sP5hDTGQwp5/Uho07DxEdHkzLxHA27DjE+m0HCXJYad4kHKvFwATaNY8iL99JRlY+rRLDaRYfgul2k5tXwBfLfqdDmyR6R4ZgsVn5Yf1+UtJzad8imuG9m3HocD5fr9rNyf1bkJvvZO1vaeQVOGnfIpqtuzMICbbRKjECwzDYtiedwoIiXEVFtGsaRqcWkWzcfgDcLlo2CSU82GDXvgwO5Vk4Y+xAFv+4k7SMPIIdVoIcVuxWC4ey8ikqcpMUF8ZfBrfCYbfy6Q87OHg4D4fNSlSYg7ZJofy6NYWiggIchhu74SLI6iYq2CDzcDaFBYUYphuL6cLATUSwhQ6tE8ARxC9bDxBsN8jLLyQpJoRgu8HOfRkYpkl4iI3CIheFRS48jxyeZYUuDMMkJiKIJtEh7Es7QnCQlaTYUHJyC9ix7zCmaWIxwMDEMMDA889imBiA1WJgsUBefhGm2wRM7zEo/t8wTexWg4i4eHqf8TeWbUpn295M8gqcR188ponFdGF1F2BzF2BzF2KYLiymCwue/z233T5/e/6VHDPIYcWKSV6BEwOT0CArTqeLImfJNhAaZKWoyIXT5fIe2jBN/BWX2+e2xWIQFxlC04Qo9mUUkHIoz/OYWK30OHUse3KC+GlzWqndmFjNIizuIqymE4vpxOou8vxvOrG4i7x1MDAxTDcGbp//zaO3/dYVP86mCQacfNn1OIKDyv0s+bMM0yzz6Bz3PvroI+688042bdqExXI0Ld95552kpaXx8ssv12i/WVl5uFzuWirl8c9qtRAZGeKtd8lLwSgnkm/Zk8nWPZn8Nbk1FsNg+YYUwoLt9GwfV2vl2bonE5fbpEtrz5dpSXn2Hcxh657D9Gofxzdr9tK3UxM6tIgiJT2X73/+g7GDW/l9gZZn8bLfeefrbZw1tA092sWRleekT4c4HFaD31OOYLUYNIsPw+bz66ugyMWhw/kUOd1YLAbNm4RhMQzW/JbGrzvSSYwN5ZR+zbFaDNb8doC8AifJPZL49qe99GwfT/P4MEzT9D6e3/28jyO5RXRoHkWX1jG43G52p2YTHxXM4mW7WL05jWE9mzKgSwKHsvI5kJmHxTCIjw5m4+8ZxEcFM6g4sKzdeoDYiGCeWfQLUeEOhvZsylerdhMfBt1bhBIfYSXIYtIqPoS4cBvrtqby1YrfAZO//6UrmTlO9h/I4mB6NmEOSIq2sy/1MP26tyIzp5Aff94LbhfDeyWQm1vAhh0HseKmWUwQ7ZqGEx/p4KfN+8nOycd0ubDiJjbCzsAeLbEFh2KNa8l3aTG8+sUWANo3j+K0QS1Z9msKa7cexMBN6/hgWsTaiHBAuN0k1Oom8/AR9u5Px1lQgMNw4jCcRASZdG8ZTm52Djk5+YSGhXLgQDpgEBwSTH5eHqFWNxazCBsu7IaJw+rG7XJhw01IZBT5hoOMzByigw2cRYUYbidWw43dANN0Y8HEYpgE2w3cRUU4DCd2w4mJFcPuILfQxIIba/E/MDEsFjAsFJlWXO2G8eSvCRiFOUQYeYRbCggz8gk3CghyWAgNCyU3M4MISz52w43FMDFNk/jIILJy8rG7Cwk1Cgg2irAanvJYcWMp/ttS/CVYUk7v38W3y/OH2YTYky/kva82QWEeYUYBIZZCIoMNDLcLqzMXh8XEYnrqGmwUEYyTYKOQoOL6W4+x//L8Ht6H/6ZEEGHkE27J9/4fbBQRZBQRbBRhM0xMqx3T6XmcHXieZ2s1jnOiyrNHszMn1PNYG0UEGUcfb5txYn73FBl2fitMIohCQoxCQowiQopfy5Y6bN0p0ez65wiOia+TfZ+QAemLL75g0qRJrFu3juDgYO/ym2++mcLCQp599tka7TcjIwen8/h8kR7IzMMA4qPLtnrk5jvZtCudXu3jsdv8m1fzCpx8tWYvLZqE0bdjE3buz+LZD3/lvJHtOalnU2JiwsjIyCEtPZcHX1lN9zaxXHVWN799mKbJHc/+j/SsAm74vx4cySvi1c9/w2a18NRNwyhyuYkMtZOT78RusxBkt/rd99UvfmPb3sN0bBHFeSPb88uOdExMurWOJSLUzpG8IjKyCpj+6mpMEx65ejA2q4UHX17FwK6JrNt2kIOH8737TIwN5ZGrBvPSks0s/WU/541sT3xUMLkFTprHh5GeVUC/Tk3IziuisMjFlj2ZvPTZZu/9rRYDl9vEYbcQGerw/IrFSXywk1bRBrnZ2Qzt34Fvf9pLYV5O8Ru+kBbRVprGhbB1Z6rnQ58iouLiOZKTjys/h8PuUNxd/8KXaz2/pJpEB1GYm0Ov9vEM6t2GJ97+2VuGVgnhHMrKw5mfT6StkFAzlxhrDlFGLkHFwcBhOD1/c/R2sMVFkMWJxe359Rlu5Hu+bDEINopq/PqqC/uD2/PHYRdx1mxCjEK/ethP0C8D8XBhwY0Fp2nBhQWXaRBh5NXaF6LLsOE2bLiwUoQVLDYMqx23YcE0rLixkFvopqggHwdO7HYbVpsVDAtH8ly4MYgIC8KwWHC6PGHWarEABm4o/tFjAcMgO89JboGT8BAHbhOy8z3vrdioEBx2K5S0WZjetovi2+AywW1CkN3q+SFkGN7twXPbBLb/cYTe9l3EWHMrrbvTsOOyOHBbbJ66GtaK/8eKWXzMQpenTlaLBbdpUOB0YbFYi78TPPXOL3JjtVqwWa2eFqLiH29HQ0DpJ9Bzu9Dp5kBmHoWFhdgNF81jQ3C6wXJkP21sByutk9uwep9Tt8Ve/H/xbcOKaVgAC6bheV1hGJhG8U8A7/9G8XaG5zkwDDAsJF92Ew6fHFCbTsgutpKutbS0NFq1auVdnpaWRufOneu1LBW1uvz4y372pGXz91EdsFTSSfrD+j/479o/mHReL6LKaQnJyS/igZdWYbEYzLjuJIIcVgqKXDhsFgzD4K2vtvDjryn06RDPDeN6FH8QwMHDeTz+5loOHs7HZrUw68ahfLZiNwcP5/OfVXv4dWc667YdIizYRocWUWTlFLJsQwppmblkHCkgv8DFaYNb0aNtLOlZBQB8tXov2/YdBsDpcvPUu+vYtu8wkWEOjuQU0iQmhNH9W7Bqcxon92lGdk4ha9dtI86aTfrhfN7Y/Qu5R7IJt+SzwygiItigsKAQOy4uCc3Ghpv9X24is+XJ5OXm8d81u4i05NHdnkkTSxZx1iMU5tnYs9ZNyiEHBiZb9mTy/n8P4Zv0k2JDSc3IxTDdRFry6Gw7TEvbIQxMIiz5xFuOEGPJIcwoICym4Oivt0LAAfwCXeyA3WenTiAVuvj2rORs8/xf/P7M+n0bg6MMb2uAJRzcKbD5QGfODbWQaMkixppDaGEBYSEF2EJrGBSO0aPmxuL5kMVCgcvAaVpwG1ZCQoLJzivCMF3YDTdBQQ6sDgd5RQa5RYBhwV2YB0B0ZCi5hSaH85xgWEmKjyAsLJhDR4pIO1xITqEbh8NBt7bxhIQEkZXnYs3WdAxXAeFGPn0cu2iav52mVWj5dhl2nBY7TmxgdWALDiYkNBTDHoTbYmdfRhFHCg3sQcE4TQspaRlERUeRmV2Au6iIHp2aEhwaQmhoCMGhIRzJd5NXBAlx4fy6M5O1G34nyHDSqmk0kRFhxESH0TwhmgIXZOQU0SQmDJvNxqbdmeQUmrRtGkWTJjEczjd5afEG7Dg5tW8zOrWOJTWzkMiIEAzDYFfKYdZtPUDOni2MC1tFkOHEaVqwhkZhDY3ACI6gyBbK+u3pWNyFRMfF0b5DS34/UIDLbXIkz8nWfVk0iwvnpH5tsIVGUIiD3QfyaN0sCrvdjhsLNpsNDAtYDAzD02rl+Wd4/953MJct+46Qk++iaZMI3lqylnNC1tDCdohcM4jmzZoQEhGJ2xbC3vQCsvNdtGvbnD2HCoiJCiMpIRocwRj2EAx7sOdvWxBYrGCxYhT/n1sIeYUu4qP9uxe/WLmbn7//njEhv2ACwZHRtGvbAiMkEiMkAsPh2a9pC2bt9gw2bU9lcM8WdGyTgGEPAlsQhs0BNocnDFVhYInbNPl6zV4yjhTwf8PberuZ3ZhERIRQkFdY5R+8vi29hUUuTBOCHJV3W1fV5u+3869lW+lp342JQfeOTTmpb1sMRzAUP+aGIxhswZ6WyRqw2SzeH7x18UPf6XKz5rcDxEcH075ZFHsPZHPfiyvoZd/t+cEYHsEFY3tjBIViOELBEep5LVntNa5TVVjtx+49+DNOyBakwsJCkpOTmTp1Kueffz4AWVlZDB8+nEceeYQzzjijRvut7gvL6XIz/ZXVRITaufz0rqzYlMrJvZsT5LBw45M/UFDkYur4frRKDD/6C6McVzz2DQBjBrbkwlM7epfvPZDNZ8t3ERnm4IuVnjmebjm/F0VON89/spFhPZty7vC23Dxnqfc+Ywe3IjLUwe60IxQUuli79Wi6/7/hbVm8bBeFTjcGUJ0nPszIJ86STb5pJ956hPa2VOyGiyLTSrQll2hLDtGW3OKgYeLA0/pR02ZzF1asuI65Ta4ZhBUXPxZ1Y3N+AknWTFoGHSGaI4SS523ir2oXgWmxUWQNJTPfU183FoLCwgkOj8BpCSIt2ySv0I0jJIQ2bZqzbEsmuZnpuLFiDQqml7mJKEtetevqNmy4HOEERzfBCIvBcIQc/cKwB3m+qIrDworfMkg74mLUoLZkHCmgWfMktv6RTeqhbE4Z3AFbcKjnA6n4teZyuzl4OJ+4yGCCg2zsz8znm5W7+MuAlsRG+v/qKixy8dWavbRrGkmX1jE4XW4278qgffMoQoKO/pZyutz8tjuTtk0jCA22+y3fsieTmW//TGvrAXo7dnPEDOakIT1o3boZLsNBnstCZFQ42ByeevmUtaqycgqJCLWTnlVAVm4hbZtGVritaZq88802Cpwml5zWqczv48r4fnGW59DhfO549n/Yi1vHEhLjueeyQX7b/J6SxfpthzhtcKsyrav7D+WSFBda6Y+o6rpv4Ur2pGV7bz87+eRa/cIvbc1vaTzzwa/e2+cOa8vZw9rW2fGOpa6DQk38+Mt+Xly8yXv78r92YXjvZrV6jPqud2GRi2uf+M57u1+nJtw4rmedH7e02NiwOhuYfkK2IDkcDi6++GJmzpxJbGwszZs3Z8aMGSQlJTFmzJhaO47bNMnJKyIi9GhCdbrcOF1ugh02UjPy2F38IfTmV1v5acsBMKFHuzgKijxf7t/8tJeVm9I4fUhrzhvZvsz+M4pbZny53G5S0vN46t113pabEh/8sJNdKUcA+HbtPiJC7X7r/7NqD2636Rd+Tu7TjO9+/oMPftjpXVZeZHBQRHNbJi0dmZzcyk1Q7n4KDqdjYBJjya3WWAS/emJgDY8jrcBOUV4eLlswrVs3Jd90kFcE4eGhHMp2EhGXwDfr0+ju3uTXbOsyDczIJIKbtCDdjOSXTbsZGLSDUMPz2IxyrGfUsX5EWKwY4XEQ24ZN+3IIjoxiwKCe5FsjcTvCMYLDMYKKv7QNg7Tf03n0nXV0bR3N5Av6eL8go0rttmunXJ7/eAMj+jQjLSOPx1Z2pKMthSNmMGef2pseXVqwfMthvvrP/0gO2kKeO4iWHTvQs1cnjOCIMsetipM7Hf27ZPRX74SKt7daLCTGHP21361tHE2jg8v9AHXYrZw+pLX3ts1qoUe7smPMbFYL3duWHehts1ro1iaWYb2asnQ97MprAsCoDoOwxYdhA2pjKGXJeLO4qGDioo7dtG4YBhef1rnGXxyVPS8xEUFYLQZFbhtFpo24Ui0rAG2SImmTVDbEGYZn3FtdSIgO8Qak2IigOg1HAPFR/l3/lT0vgcb3PQieYQInOofdSmxkkPc7KjHmxD/ppbQTMiABTJo0CafTybRp08jPz2fgwIG8+OKL2O32yu9cRa98tpkf1u/nnksHeH+lvrRkM2u2pPHAFYNIzzo6LuaXHYcA2Hsgh7CQo2VYuckzHmXJ8l2c2r8FMRFBFDndZOcVcd/ClWTnHR03kl/owjRNpr+yhl2pR8otU0k4KvHxj78DcMnYziz/NYUtew/7re/TIZ6/n9KB5RtTKSj0hDab1cDpMokw8rj5JIP9m3/FVnCYzo79xQNQgeITEiJ8PlezCcFuFpFlRJDUsTv/+TUTq+mkdbtWdOnSDiM8joPZLjKOFNCppOncYsUICsOw2iCviM+W72JYr6aExYXh+9UQXfIYHN7EU+tak2DJItsMJjjITu8uzRh/WjcMw6Cp22T6L9/zWV4f4q1HiLccYWzIOlxYKApLol3XzliiEjFCoz0hJDTK08xveH5hDMTzSysyJgxXBV+YXdvEMuP6kwgPOXZTf1JsKPdeNhCAr9fsJdcMYl2RJ2BENW2JJSSCpgnwu7MJvzs9YeGmjj2xtWhS4T4bg9IflHGRdXOGyfHAc3ZPMGmZnpbD+MjjIxg08XkOkuLqJoT5io/2r3e8ApKfhFj/90RjCROJMaFHA1IjCH2lnbAByWq1cscdd3DHHXfU2TF+WL8fgDf/s4W7LxmAaZr8vO0ghUVuftl+yO+Mp6LiL9qU9FzstvK/VN/8zxaycgvZuf8IPdrG+oUjgMzsArLzirzhqEWTcHp3iGPxsl20aBLO3gOeX4Q2q4W/DGzBZ8t3A543W3L3JBKiQ5j59s9YLQbnjWzPum0H+fuoDoQE2bj5b71Y/etummRtpAdbyMnIINGaiWUTNAHPuBvACI3GEtcSS0wLrPGtMcLj2HswFyM0mh2Hbbz2xW9cdWY32vVIIjxyL1v2ZHLqX7pgL+6CSSr+V57wEDvnn9LhmI95y4QITCykuqMBuOMfA2mVGOFdb7EYtE2KYPNuF0ecIewkgVWFnpa5s3u0oevAdsfcf1XFRFTvSz2u1BdjyS/opFIfGqV/STZGCT51DAu2Eew4YT9mqqRJ9NGAdLy0nCRE+wakun/NhQbZCAmyklfg+RFWukUp0EWE2AkJspFX4CTIYa30rNsTRWJMCJt2ZXj/bmwa9ydXLSkJLBlHCrxzV+zcf4TYcn4Zp6bnFs87UdaaLQe8f/+8rezI/8wjBWQc8aTxiFA7D17pGcvQrXUMSXFhvP7lb6zffohbzu9Fk+gQvljhGZd07Tk9CLJb6dYmlqvO7EZEmJ0ebeM4bVAr3NmHyP9xES3/2ETzjD8o6VyLLH7mg5p2wGjWDbcjDFvz7lhjW5QpV5vixNPKNBncNZHQYM+dT+3fglP7l93+z2iV6D83TpNyztpr2yySzbszyywvPaamPvl+MQbZrYQVP0YhQTZvM7RhlF+fxsb3y7l0cGyMPGeWer4kjpf6+rYgNa2HgGQYnnly9h7Ixmoxqv0Do7EzDIPEmBB+TzlCYkxItcfdHa98fwwlNMIffwpIVeB0mdz69FKifMYi/Z6ShUlEmW1zC5zkHnD6LQsPsXPR6I6s2XKAgkIXv+5M964LC7aRU3xaaWZ2AZnZnoAUHX70A6ZrG894j2vP6UFugdN7ptsd/+iD3WalddLRciT38KQZ95GDFP7yBUUbvwX30fIYEU2wdx2JNa4VjiYtiWvZsspjMwzD8IajutKiydGAFF78q6u0dk1LjwbyiG3AD2XfL8a4qGC/D8CmcZ6pB+Iig8tMw9AYJfh8OR8vLSp1yTf0Hi/19S1T6VbMuhIfFczeA9nERgb5TSYqHomxocUBqfEEicTirsMgu5Xo8MbRKuZLAekYfMPL4exCDmcfvRBuyqFcvy620uKjgjEMOJCZT/tmkQzpnsSQ7p7w8sInG1m2IYUuraK5+fzeHMkp5M75y8jKLfLO91PeLzC7zUKU7eiLsHPx7MQlTNPEnbadgjUf4tp79IwSa9Mu2Hv+BWtCeyyh0d7lluPwyzokyEZCdAhpmXl+X7S+2jUr/6ylmAb89R4abPM2oZduRWgaF8qGnemNsgm6PCFBNiJD7WTlFjVoq1598R1vc7y0IMVFBmG3WShyuutsIHhpJY+DutfK16lFFCs2ptKxRfk/8E5EHZpHERnmoFubmEbTKuZLAekYio4xq7YJfqfRljawSwIp6bkcyMynXXP/N8T5p7THZjUY1a8FQXYrjqhg7+SFvxcPwvZtQaoK576NFCx/C/ehPcVLDKzNuuDocwbW5t1PqBdvy8RwT0CqoDvKNzyWfAlAw7YggefLce+B7DKtCL3axfHNmn30LOeMsMYqISaUrNzDx01gqEslLQJhwbY6b2GtKqvFwlVndaPI9LQm1cdp3y2Lu8dbJpR/CZlAN7Jvc7q3i6PJcdLKWBsiQh3MumFoo20xPD7ezceJPWnZvLJkE6cnt6Fnu1gKi8r/UAmyW72n8VdkUNdErFaD+KgQTu3nP04nOjyIy0/v6r1tGAbR4UEcysrn9/1ZQNUHCZtuNwUr/03R+s89C6w2bO2HENTvbCyRxzj/+zjWq10ca347QOdW0RVu88+L+7M77Qj7DuTw7dp9hATZyu2Oq08lXQylz9rq0S6OZyaP8JsDp7Eb3C2RtMw8epQzHUBj0yoxnDNPak3zCq4t11CGdE/yTm9QH07qkURcZHCFLbyBzjCMCn/0ncgaazgCBSQ/36/7gy17D7Pl3XU8dOXRyd6evmU4W/YcZs776wEYPaAFi5ft8q5PjA0lNT2XLq2ivYOHWyWGYxgG/xjdkaqIifAEpL0HPB9mVenPdWelkf/Dy7j2bQTA3m0UQQPGYQQfXx/U1TW8dzP6dIz3m3+qtA4toujQIopP/vc7QLkD5uvbqQNa4HS5vddL8xVI4Qg8A/hH9Wt+QrVc1pRhGIwb0b7yDRs5q8UzD5ZIY6GA5MNmPfph/vLnR6/dFeyw0a1NDPFRwVitFs4e2sYvIF11Zjd2px5hYNcEXv38N4b3alrtL4bSgehYLUim203husUU/vQxuIrAaif45CuxdxhSrWMez44VjnyV/CI7HgY+dm8TS3d9QXgFQjgSkcZLAcmXz0TRv+/3jAWyWS1YLAYOi5UHrxyEYRjYbVYuHNWBt7/ZRv9OTWjXLNLbrHzduT1qdOjoUoGoojFIpttJ/jfP49yxEgBr824ED7sES1RFsw81bv07N2HCmE50D6DxPSIiUvcUkHy43GaZv4PsR8/08p3w7i8DW9I8IdzvtPQ/o2Wp/ZTXgmQ6C8j7ah6u3evAYiV4+GXYOg0L6F/qNquFU/rV7lxMIiIix9953g3I7S57rTFHBWNHDMOge5tY75xEf9agbv7jVsJD/C+ZYuZnk7t4hiccWR2EjJmEvfPwgA5HIiIidUUByYervIBUT3MFBdmtDOxy9Kwz3+BjFhWQ++m/cKduA0cooWfcga1V73opl4iISCBSF5uPcgNSPZ59NOG0zuQVOundPt5vef6Pr+NO34MREkXIGXeUezkQERERqT0KSD5c7rLzHjns9dfIFh5iZ/Lf+/gtK9r8Pc4tPwAGwadep3AkIiJSD9TF5qPcMUi2hpu/xpWylfylr3jK0f9cbM26NFhZREREAokCkg+Xq2xAaqgJ/kxnAXn/fQHcLmxtB+Dod1aDlENERCQQKSD5cJnljUFqmIeoYNUizKw0jLBYgk++AsPQUyUiIlJf9K3rozqn+dcl18FdFP36JQDBwy/FcDT8LNEiIiKBRAHJR3lnsQXV8xgk03STv/RVME1s7QbpdH4REZEGoIDko7wxSPXdxVa0+XvcadvBHkxQ8j/q9dgiIiLioYDko6QFKSTo6OwH9dnF5sr8g4KV7wIQNGAclrCYeju2iIiIHKV5kHy4i+dBCgu2kVfgBOqvBcmVspXcz2dBYR6W+NbYu59aL8cVERGRstSC5KOkBSks+Oh10OpjHiR3Vhp5X86BwjysiR0J+ettGJaGm39JREQk0KkFyYc3IIX4drHVfYbM//4lzPwjWOLbEHL67Rj2oDo/poiIiFRMLUg+3OW0INX1RJGug7tw/bEJDAshf7lB4UhEROQ4oIDk42gLUv11sRX++h8AbO0GYoloUqfHEhERkapRQPJxdAxS/XSxuXMP49y23HOcnmPq7DgiIiJSPQpIPsodpF2HXWxFm74FtxNLQnusCe3r7DgiIiJSPQpIPtzltSDZ6uYhMl1FFG38xnMMtR6JiIgcVxSQfLhK5kHyGYMU5KibFiTnzjWYeVkYYTHY2vavk2OIiIhIzSgg+Sh3DFIdDdIu2rIUAHvn4RgWzbYgIiJyPNE3sw/f0/zDQ+wUOd1+YanWjpN9CNfeDQDYOw2r9f2LiIjIn6OA5KOkBclmszB1fD9cbrNOBml7Wo9MrE27YIlMqPX9i4iIyJ+jgOTD5fIEJIvFICk2tE6OYZpuin472r0mIiIixx+NQfJR0sVmNYw6O4Zr/2+YRw6APRhbuwF1dhwRERGpOQUkHyVdbFZr3QUk7+Ds9kMwbLqsiIiIyPFIAamYaZq4zaNdbHVyDLcL566fAbB1TK6TY4iIiMifp4BUDmsdBSRXylYoyMEICsea2KFOjiEiIiJ/ngJSOeoqIDl3rfXsv1VvDEvdXgRXREREak4BqVhx7xpQNwHJNE1vQLK16Vvr+xcREZHao4BUjroYg+TO/AMzKw2sNmwtetT6/kVERKT2KCAV82lAwlIHp/k7fy/uXmvWDcMeXOv7FxERkdqjgORVfIq/xcCoi4BU0r3WWt1rIiIixzsFpBLFTUh10r2Wexh32g4AbK371Pr+RUREpHYpIBUr6WKri4Dk2rcBMLHEtcYSFlPr+xcREZHapYBUiq0OApJz3yYArM271fq+RUREpPYpIBUz66iLzTTN4hYksCkgiYiInBAUkEqp9YCUlYqZkw4WG9akTrW6bxEREakbCkheR89iq03OPzZ79pvYHsOui9OKiIicCBSQipV0sdV2QHKlbPXst2nnWt2viIiI1B0FpFIsltp9SFxp2wCwJujitCIiIicKBaRiJaf512YLkjsvC/Nwqme/ie1rbb8iIiJStxSQSpScxVaLs2i707Z79hndDCMorNb2KyIiInVLAcmreJC2tfYCkiu1uHstUd1rIiIiJxIFpGJ10cVWEpAs6l4TERE5oSgglajliSJNtxNX2k4ArIkda2WfIiIiUj8UkIqVtCDV1qVG3If2gqsQHKFYopNqZZ8iIiJSPxSQSqmtFiRXavH8R4ntMQw9zCIiIicSfXOXqOUuNleq5ww2DdAWERE58SggFTNLzmKrpdP8XcWn+GuCSBERkROPAlIpVuuff0jMwlzMIwc8+4tv/af3JyIiIvVLAamU2uhic6XvA8AIi8UIDv/T+xMREZH6pYBUrDYvVutO3wOAJbbFn96XiIiI1D8FpFJqJSAd8gQka1zLP70vERERqX8KSMVKBmnXRhebO32vZ1+xCkgiIiInIgWkErXUxWaaJi5vF5sCkoiIyIlIAalYyUzaf7YFycw+CEX5YLFiiU788wUTERGReqeAVMqfbUFyF5/BZoluhmGx1UaRREREpJ4pIJWopS42V0bJ+KPmf7ZEIiIi0kAUkIrVVhebtwUpRgFJRETkRFWnAenee+9l6tSpZZYvW7aMcePG0bt3b8aOHcvixYv91hcUFPDAAw+QnJxM3759ue2220hPT6/WPqqv+FIjlj/3kLgzPAHJGqM5kERERE5UdRKQ3G43s2bN4p133imzbvv27VxzzTUMHz6cRYsWcf7553PnnXeybNky7zb3338/S5cuZe7cubzyyivs2LGDSZMmVWsf1VXSgvRnuthMtwt35h+AuthEREROZLU+inj79u3cfffd7Nq1i2bNmpVZ/8orr9C5c2duvfVWANq3b8/GjRtZsGABycnJpKam8uGHHzJ//nwGDBgAwKxZsxg7dixr166lb9++le6jRooT0p/pYjOz0sDlBJsDIyK+xvsRERGRhlXrAWn58uW0b9+eZ555hltuuaXM+tWrVzN69Gi/ZUOGDOHhhx/GNE3WrFnjXVaibdu2JCYmsmrVKvr27VvpPgyj5iHHbrNgs9WsYa3wsKf1yBrTHLv9+D+DreTCvLVxgd4TieqtegcC1Vv1DgR/4uu+UrX+LT5+/Phjrk9JSSEpKclvWUJCAnl5eWRkZJCamkpMTAxBQUFltklJSanSPmJjY6td7pIutojwIGJiwqp9f4CMvDRygJCmbWq8j4YQGRnS0EVoEKp3YFG9A4vqLX9WtQLS3r17OfXUUytcv2zZskrDSX5+Pg6Hw29Zye3CwkLy8vLKrAcICgqioKCgSvuokeKEVJBfREZGTo12kb1vJwCu8KQa76M+Wa0WIiNDyMrKw+VyN3Rx6o3qrXoHAtVb9Q4EUVEhWP7kyVUVqVZASkxMZMmSJRWuj4qKqnQfQUFBZUJMye2QkBCCg4PLDTkFBQWEhIRUaR81YXrbkMDprNmLy3XIMwcSUU1rvI+G4HK5T6jy1hbVO7Co3oFF9Q4Mpln5NjVVrYBkt9tp3779nzpg06ZNSUtL81uWlpZGaGgoERERJCUlkZmZSWFhoV8rUVpaGomJiVXax59R00HapqsI92FPF6BFp/iLiIic0Op9NNeAAQNYuXKl37Lly5fTr18/LBYL/fv3x+12ewdrA+zcuZPU1FQGDhxYpX3UyJ+cSdudmQKmGxwhGGExNSuDiIiIHBfqPSBNmDCB9evXM3PmTLZv387ChQv5/PPPmThxIuDpxjvjjDOYNm0aK1asYP369UyePJlBgwbRp0+fKu2jJv7sPEglE0RaYpr/qbPoREREpOHVe0Dq2LEj8+bN47vvvuPcc8/l3XffZcaMGX7zFz300EMkJydz4403cuWVV9KuXTvmzJlTrX3UlKWG4cad7hl/pBm0RURETnx1OlnPa6+9Vu7yESNGMGLEiArvFxoayvTp05k+fXqF21S2j5qqaevP0fFHTWuzOCIiItIAAmtGqWMp7mOrae+YO8szaNwSmVBLBRIREZGGooBUC0zTxJ11AABDAUlEROSEp4BUrGSQdo262ApyoCgPAIuuwSYiInLCU0Dy8kSkmvSwlXSvGaHRGLagSrYWERGR450CUik1aUDS+CMREZHGRQGpjOonJPeR4vFHEU1quzAiIiLSABSQSqnJPJFm8QBtS6QCkoiISGOggFSauthEREQCngJSKcaf6GKzqItNRESkUVBAKq2a+ch0OTGz0z13VRebiIhIo6CAVEp1xyCZRw4CJtgcGCFRdVImERERqV8KSMVM71/VS0juI8XjjyISanwdNxERETm+KCCVqOG12Nw6g01ERKTRUUAqpbptQN5ZtHUGm4iISKOhgFRKdbvJTJ3BJiIi0ugoIJWmLjYREZGAp4BUSnXykWmamiRSRESkEVJAKqU6XWxm/hFwFnjuFx5XV0USERGReqaAVEq1WpByiieIDInCsDnqpkAiIiJS7xSQSqnOGG0zO8Nzn/DYOiqNiIiINAQFpGJm5ZuU4S5uQbKExdRuYURERKRBKSCVMD0RqVpjkHKKW5AUkERERBoVBaRSqtPFVtKCZISpi01ERKQxUUAqxajGMO2SFiR1sYmIiDQuCkilqQVJREQk4CkglVLVLjbTNL1nsVl0FpuIiEijooBUSpW72ApywFXouU9odN0VSEREROqdAlIpVW1BcpecwRYcoUkiRUREGhkFpGIl8yBVuYvNO/5IA7RFREQaGwWkUqraxebWHEgiIiKNlgJSDR09xV8DtEVERBobBaRS1MUmIiIiCkilVPVSIyVdbDrFX0REpPFRQCpRPEq7qvNEmpokUkREpNFSQCqtqqf5Z+syIyIiIo2VAlIpVclHZmEeFOV5tldAEhERaXQUkEqpyhikkvFHOEIx7MF1XCIRERGpbwpIxaozUWTJ+COd4i8iItI4KSDVQMkcSEa4utdEREQaIwWkUixV6mIraUFSQBIREWmMFJBKq1IXW3ELUqgCkoiISGOkgOTlGYVUpbPYcg97tg2NrrviiIiISINRQCqtKl1sxQHJooAkIiLSKCkglSg+ja0qD4iZmwmAERpVZ8URERGRhqOAVFolDUimaWLmlXSxKSCJiIg0RgpIxbzzIFWWkApywO3ybBuigCQiItIYKSCVUtkQJHdJ91pQOIbVVvcFEhERkXqngFRKZZcaOXoGm1qPREREGisFpGo6OkA7ukHLISIiInVHAamUyrrYvAO0QyLroTQiIiLSEBSQSqmsi82tSSJFREQaPQWkUiqbJtL0ThKpMUgiIiKNlQJSaZV1sWkMkoiISKOngFRKpS1IeVme7TQGSUREpNFSQCql0tP88494tguJqI/iiIiISANQQCrlWPnIdLsxC7I92wUrIImIiDRWCkilHKv9yCzMAdNzURIjOLx+CiQiIiL1TgGpjIojUkn3Go5QDIsuMyIiItJYKSCVcswutrzi8UfqXhMREWnUFJBKOWZAyi8ef6QB2iIiIo2aAlIpRhW62IwgjT8SERFpzBSQSjtmC5InIFnUgiQiItKoKSCVYtEYJBERkYCngFRGFbrYFJBEREQaNQWkUo49SLskIGkMkoiISGOmgFSKzmITERERBaRSqnQWm7rYREREGjUFpNKq1MWmgCQiItKY1XpA2r9/P5MnT2bo0KEMHDiQK6+8kq1bt/pt89lnn3H66afTq1cvzj33XJYtW+a3PiMjg9tuu42BAwcyaNAgHnjgAfLy8qq1j5qqKB+ZzgJwFnq2UUASERFp1Go1IBUWFnL11Vdz4MAB5s+fz5tvvklYWBiXXnop6enpACxfvpw77riDCy+8kA8++IDk5GSuvvpqtm/f7t3PpEmT2LVrFy+//DKzZ8/mu+++4/777/eur8o+asqoYBBSyfgjLDawB//p44iIiMjxq1YD0urVq9myZQszZ86kZ8+edOzYkRkzZpCbm8s333wDwAsvvMDo0aO55JJLaN++PVOmTKF79+688sorAKxdu5aVK1fyr3/9i+7du5OcnMyDDz7IRx99RGpqapX2UVPH6F3zmQMpvMIQJSIiIo1DrQakjh078vzzz5OYmHj0ABbPIbKysnC73fz0008kJyf73W/w4MGsWrUK8ISsJk2a0L59e+/6QYMGYRgGa9asqdI+aqwq4490BpuIiEijZ6vNnTVp0oSTTz7Zb9lrr71Gfn4+Q4cOJSsri9zcXJKSkvy2SUhIICUlBYDU1FSaNm3qt97hcBAdHc3+/furtI+aMjCw2crPjK5CTxebJSSiwm1ONFarxe//QKF6q96BQPVWvQNBXXboVCsg7d27l1NPPbXC9cuWLSM2NtZ7+z//+Q9PPPEEl112GZ07d/YGGIfD4Xe/oKAgCgoKAMjLyyuz3neb/Pz8SvdRUxYLxMSElbvusKWQXCAoMqbCbU5UkZEhDV2EBqF6BxbVO7Co3vJnVSsgJSYmsmTJkgrXR0VFef9+6623eOihhzj77LO58847AU+IAc9gbl8FBQWEhHie1ODg4DLrS7YJDQ2t0j7+jIyMnHKX5x06CIDTGlLhNicaq9VCZGQIWVl5uFzuhi5OvVG9Ve9AoHqr3oEgKirEO5SntlUrINntdr+xQRWZMWMGCxYs4PLLL2fKlCneQc3R0dGEhoaSlpbmt31aWpp33FJSUhJfffWV3/rCwkIyMzNJSEio0j5qysDA6Sz/heXK9YxBMh0RFW5zonK53I2uTlWhegcW1TuwqN6BwTTrbt+1HrtKwtGUKVOYOnWq3xlfhmHQr18/Vq5c6XefFStWMGDAAAAGDhxISkoKu3bt8q4v2b5///5V2kdN6TpsIiIiArU8SHvFihUsWLCACRMmcNZZZ3HgwAHvutDQUMLCwrj88su5+uqr6datGyNGjOD9999n06ZNPPzwwwD07t2bfv36ceutt3L//feTm5vLvffey7nnnuttIapsHzWms9hERESEWm5B+vTTTwHPmWvDhg3z+7dw4UIAhg0bxiOPPMJbb73F//3f/7F8+XLmz5/v7bozDIOnn36aFi1acOmll3LLLbcwYsQIv4kiK9tHTek6bCIiIgJgmGZd9uCdOFIO5XDTzG+ZN/nkctdnv3oTZv4RQs+bjjW2RT2Xrm7YbBZiYsLIyMgJqD5r1Vv1DgSqt+odCGJjw+psaoPAmjChEhWNQTLdbu+lRjQGSUREpPFTQPJRURebWZgDeBraFJBEREQaPwUkXxW1IBVfhw1HKIalVse1i4iIyHFIAclHRUO0dQabiIhIYFFA8mFUMAjJO/4oSN1rIiIigUAByUeFE0UWeC4tYgQ1rmuwiYiISPkUkKrAVEASEREJKApIPiwVdbEpIImIiAQUBSRfFZ3FpoAkIiISUBSQfFR4FpsCkoiISEBRQPJR4VlsCkgiIiIBRQHJR4UtSIW5nvUKSCIiIgFBAclXRWOQvPMgKSCJiIgEAgUkHxVei624iw0FJBERkYCggOSjvCFIptsNhXme9QpIIiIiAUEByUe5g7QLcwHTs14BSUREJCAoIPkor4OtZIA2tiAMq61eyyMiIiINQwHJV3ldbBqgLSIiEnAUkHyU18WmU/xFREQCjwKSj3K72LwtSKH1WxgRERFpMApIPso9i00tSCIiIgFHAakSGoMkIiISeBSQfFiOMQZJk0SKiIgEDgUkX+UNQirpYnOE1G9ZREREpMEoIPkofx6kfM86hwZpi4iIBAoFJB/HPM1fLUgiIiIBQwHJR/lnsXmuw4ZdAUlERCRQKCBVpuRCtWpBEhERCRgKSD6O3cWmMUgiIiKBQgHJR7ldbEUlg7TVgiQiIhIoFJB8GKXOYzPdbigOSCggiYiIBAwFJB9lWpCK8o6uU0ASEREJGApIx+CdRdtqw7DaG7YwIiIiUm8UkHyUHqStSSJFREQCkwKSj9JdbN4WJHWviYiIBBQFJB9lTmLzzoGkFiQREZFAooB0DN45kOzBDVwSERERqU8KSD4sZcYgqQVJREQkECkg+So9BqnkNH+NQRIREQkoCkg+Kh6DpIAkIiISSBSQfJQ9zV9dbCIiIoFIAclHRaf5Gw4N0hYREQkkCkh+ym9BQi1IIiIiAUUByUeZa7FpDJKIiEhAUkDyUbaLTWOQREREApECkg+jTBdbyRgktSCJiIgEEgUkHxW1IGFXQBIREQkkCkgVME0TijQGSUREJBApIPnwmwfJWQCm6VmuMUgiIiIBRQHJh28+8navGRawORqmQCIiItIgFJB8+A5BKhmgjSOkzAzbIiIi0rgpIPnyzUE6xV9ERCRgKSD5sPi0FB2dA0mXGREREQk0CkgV0CSRIiIigUsByYf/IO3iMUiaA0lERCTgKCD58BuMreuwiYiIBCwFJB/lncWmLjYREZHAo4Dky3eQdlG+Z5FakERERAKOApKPiuZBEhERkcCigOTDKHceJAUkERGRQKOA5MOgvHmQNAZJREQk0Cgg+SjvWmxqQRIREQk8CkgV8F6sVgFJREQk4Cgg+fCfB6nkNH8FJBERkUCjgOSj/C42jUESEREJNApIPkrykeksBLfTs0wtSCIiIgFHAclHSRdbySSRANiDG6g0IiIi0lAUkHx4u9i8F6oNxjD0EImIiAQaffuXQ+OPREREAlutB6Tdu3dz3XXXMWDAAAYMGMDkyZNJTU3122bZsmWMGzeO3r17M3bsWBYvXuy3vqCggAceeIDk5GT69u3LbbfdRnp6erX2URPeLjbNgSQiIhLQajUgFRYWctlll+F2u3nzzTd57bXXSEtL49prr8U0TQC2b9/ONddcw/Dhw1m0aBHnn38+d955J8uWLfPu5/7772fp0qXMnTuXV155hR07djBp0iTv+qrsoyZKuth0HTYREZHAZqvNne3fv5+ePXty3333ERsbC8Bll13GDTfcQEZGBrGxsbzyyit07tyZW2+9FYD27duzceNGFixYQHJyMqmpqXz44YfMnz+fAQMGADBr1izGjh3L2rVr6du3b6X7qCnvWf7qYhMREQlotdqC1Lp1a2bPnu0NR3/88QdvvfUW3bt3JyYmBoDVq1eXCTFDhgxhzZo1mKbJmjVrvMtKtG3blsTERFatWlWlfdRY6S42ncEmIiISkGq1BcnXFVdcwY8//khUVBSvvPKKd3xPSkoKSUlJftsmJCSQl5dHRkYGqampxMTEEBQUVGablJSUKu2jJKBVl8UwsNksFDk9p/lbgsOw2RrvOHar1eL3f6BQvVXvQKB6q96BwHeC59pWrYC0d+9eTj311ArXL1u2zBtO7rjjDm6++WaeeeYZLrvsMj788EOaNm1Kfn4+DofD734ltwsLC8nLyyuzHiAoKIiCggKASvdRU8FBNmJiwnBbisgHQiIjiYkJq/H+ThSRkYE51kr1Diyqd2BRveXPqlZASkxMZMmSJRWuj4qK8v7dtWtXAJ566ilOOeUU3n//fW688UaCgoLKhJiS2yEhIQQHB5cbcgoKCggJ8Tzxle2jpgqLXGRk5JCXleU5pttORkZOjfd3vLNaLURGhpCVlYfL5W7o4tQb1Vv1DgSqt+odCKKiQrBY6qbVrFoByW630759+wrX79+/n3Xr1jF27FjvstDQUFq0aEFaWhoATZs29f5dIi0tjdDQUCIiIkhKSiIzM5PCwkK/VqK0tDQSExOrtI8aM02cTjfuAs9ZbKYtGKez8b/QXC53QNSzNNU7sKjegUX1Dgx/ZthxZWo1dm3evJmbb76ZHTt2eJdlZWWxc+dOb7AaMGAAK1eu9Lvf8uXL6devHxaLhf79++N2u72DtQF27txJamoqAwcOrNI+auroaf6aB0lERCSQ1WpAGjp0KF26dGHKlCn8+uuvbNiwgUmTJhETE8Pf/vY3ACZMmMD69euZOXMm27dvZ+HChXz++edMnDgR8HTjnXHGGUybNo0VK1awfv16Jk+ezKBBg+jTp0+V9lFj3rPYNA+SiIhIIKvVgORwOHjhhRdo1aoVEydOZMKECURGRvL6668THh4OQMeOHZk3bx7fffcd5557Lu+++y4zZszwO23/oYceIjk5mRtvvJErr7ySdu3aMWfOHO/6quyjJsrOg6SAJCIiEogM809NHNR4pBzKYdE3Wzh/ZAeyX78FMzeT0HEPYI1v3dBFqzM2m4WYmDAyMnICqs9a9Va9A4HqrXoHgtjYsDqb2iCwJkyohK7FJiIiIqCA5McATLcLnJ75ljQGSUREJDApIPky8I4/ArUgiYiIBCoFJB8GBmZRcUCyOjAsdXYlFhERETmOKSD5MAyNPxIREREFJD8GRwOSxh+JiIgELgUkX4YBRfmePxWQREREApYCkg+LAWaR5ww2wxbUwKURERGRhqKAVFpxCxJ2BSQREZFApYDkwzAMTKdakERERAKdApIPAzBLxiDZgxu2MCIiItJgFJB8GAZQPAZJXWwiIiKBSwHJh18Xm1qQREREApYCUmkapC0iIhLwFJB8GH6n+asFSUREJFApIPkwDMNnkLZakERERAKVApIPA8CpQdoiIiKBTgHJl+Fzmr+62ERERAKWApIPA8M7BkktSCIiIoFLAcmHZx4kTRQpIiIS6BSQfBgGPvMgqQVJREQkUCkg+TI5OpO2rsUmIiISsBSQfFhxgukG1MUmIiISyBSQfFjdhUdvqAVJREQkYCkg+bC6i4r/cGBY9NCIiIgEKqUAHyUtSBqgLSIiEtgUkHx4u9g0/khERCSgKSD5sKkFSURERFBA8mNxFbcgaYC2iIhIQFNA8mE1S1qQ1MUmIiISyBSQfFjUxSYiIiIoIPmxqotNREREUEDyY3HrOmwiIiKigOTHO1GkWpBEREQCmgKSD4vLE5DUgiQiIhLYFJB8lAzSxuZo2IKIiIhIg1JA8uE9i01dbCIiIgFNAcmHpXgMkgKSiIhIYFNA8nF0Jm11sYmIiAQyBSQf3hYkDdIWEREJaApIPnQtNhEREQEFJD9HB2mri01ERCSQKSD5MIrnQUJdbCIiIgFNAcmHTvMXERERUEDy421BUhebiIhIQFNA8mFgev5XC5KIiEhAU0AqVhKOAJ3FJiIiEuAUkIp5A5LVhmHRwyIiIhLIbA1dgOOFUfJHJa1Hbrcbl8tZ5+WpD263QX6+lcLCAlwus/I7NBLl1dtqtWFRMBYRkWIKSMVKAlJF449M0yQrK528vOz6K1Q9OHjQgtvtbuhi1Lvy6h0SEk5kZCyGYVRwLxERCRQKSF7FLSgVnMFWEo7Cw2NwOIIazZeo1WoEVOtRCd96m6ZJYWEB2dkZAERFxTVk0URE5DiggFTsWGewud0ubzgKD4+s76LVKZvNgtMZeC1IpevtcHie9+zsDCIiYtTdJiIS4PQtUOxoF1vZFiSXywUc/RKVxqnk+W0sY8xERKTmFJCKGUZxN9MxLjPSWLrVpHx6fkVEpIQCUrHKBmmLiIhI4FBA8jr2IG0REREJHApIxdSCdPy58carefjh+xu6GCIiEoAUkIoZakESERGRYgpIxbwtSMcYpC0iIiKBQfMgFTvaglT1gGSaJoVFDTOHkMNuqdFZV8OGDeDyy69iyZJPcDqLePbZF2nSJJEXXniWL7/8jJycbNq2bc/EidcyaNAQtm/fxqWXXsiLL75O585dALjrrtv56adVLFnyDVarFbfbzdlnj+GmmyZz2mmn88knH/Lee2+zZ88eLBaDTp26MGnSZLp06QbAeeedxciRp7J8+Y9kZKQzffrjdO/ek/nz5/Lll59TVFTIOef8DdP0n8DyzTdf48MP3+PAgTTi45twxhlnc+mlV+rsMxERqXUKSKWUNw9SeUzT5NHXf2LbvsN1XKLydWgRxV3j+9UoHHzwwbvMnDkHp9NFq1atmDbtLnbt2sm99z5EkyYJ/Pjj99x55y088shMTjppGE2bNmPVquV07twFl8vF2rWryc3NZcuWzXTt2p2NGzdw5MgRkpOH8d133/Lkk48zZco0evfuy8GDB3nqqRk89th0Xn75TW8ZFi36N//615NERETQrl0HnnpqBj/++AN3330fiYlNefXVhaxbt5ZmzZoDsHTp97z22ks8+OAjtGzZhg0b1jN9+n00bdqM0047vdYeVxEREVBA8vK2IFWni+0Ebbg47bTTva05e/bs5quvvuCll96gY8fOAFx44cVs27aVN998lZNOGsbQocNZtWoFF198GZs2bcBms9OjR09++mk1Xbt2Z9mypfTu3ZfIyEiioqKYOvUexoz5KwBJSU0588yzmTXrcb8yDBkylIEDBwOQm5vDZ599ym23TSE5eRgAd911Lz/9tNq7/R9/7MXhsJOU1IykpCSSkpKIj08gMTGpzh8vEREJPApIxUoaYqragmQYBneN73fCdbEBtGjRyvv3li2/AXD99RP9tnE6nYSHRwAwdOhwPv74AwoK8lm1agX9+w8gKakZa9asZvz4S1m2bCljx54JQJ8+/fj99528/PICdu36nb17d7N9+7YyF4Zt0aKl9+/du3dRVFREly7dvcuCgoLo1Kmz9/aYMaezePHH/OMf42jTph0DBw5m5MhTSUpSQBIRkdqngFTMey02e3DV72MYBDmsdVWkOhMUdLSVrCS4PPPMC4SGhvltV3I9sr59B2C321m79idWr17JaaedTtOmTVm06N+kpOxn69YtPPzwyQB8+eXnPPzwfYwZ81d69OjFOeeMY8eO7cya9a8Ky1DSFGea/iHKZjv68oyOjuall97k11/Xs2rVClasWMa7777FlVdew+WXX/XnHhAREZFSdBZbMW9bTDUCUmPQvn0HAA4dOkiLFi29/xYv/pglSz4BPEFl0KBkli79jo0bf6V//4H06tUHl8vFiy8+R7t2HWjatBkAb7zxMmeddS53330/f/vb3+nTpx/79u0FKDPoukSrVq1xOIJYv36dd5nT6WTr1i3e219++RkffPAevXr14corr+H55z3H+frrL+vkcRERkcCmgFTsaAtSSAOXpH61a9eek04azowZj7J06ffs27eXN954hddff5nmzVt4txs2bARLlnxCfHwTmjdvQVBQMD169OKLL5YwfPjJ3u0SEhL55Zd1/PbbZvbt28s777zBokX/BqCwsLDcMoSGhnLeeX9n4cLn+O67b9i163dmznyUgwcPeLcpLCzgmWdm8/nni9m//w/WrfuZtWt/okePXnX0yIiISCBTF1uxowEp8OZBevDBR3n++WeYMeMRjhzJolmzFkydeg9//euZ3m2Sk4ficrno12+Ad9mAAYP46afVDBt2NCDdeuudPP74w9x449U4HHY6dOjEtGkPcN99/2Tz5o307t233DJcc82NOBxBzJr1L3Jzcxk16i8MHTrCu/7MM8/l8OHDvPzyAtLSUomIiGDkyFO57rpJdfCIiIhIoDPMivo9AkxRRip75l1P2PgnsYTF+K8rKuTQof3ExTXFbm9cM23bbBaczoYZaN6Qyqt3Y36ewVPnmJgwMjJyAuo5V71V70AQqPWOjQ3Daq2bzjB1sZVSnUHaIiIi0jjVaUBavXo1Xbt2ZcWKFX7Lly1bxrhx4+jduzdjx45l8eLFfusLCgp44IEHSE5Opm/fvtx2222kp6dXax81FoBdbCIiIuKvzgLSkSNHuPPOO8vMf7N9+3auueYahg8fzqJFizj//PO58847WbZsmXeb+++/n6VLlzJ37lxeeeUVduzYwaRJk6q1j5owrQ4MQ41qIiIiga7OBmnff//9tGzZkn379vktf+WVV+jcuTO33norAO3bt2fjxo0sWLCA5ORkUlNT+fDDD5k/fz4DBngGBM+aNYuxY8eydu1a+vbtW+k+asq0qXtNRERE6qgF6aOPPmLt2rX885//LLNu9erVZULMkCFDWLNmDaZpsmbNGu+yEm3btiUxMZFVq1ZVaR81Vo0L1YqIiEjjVestSHv37uXhhx9m3rx5hIWFlVmfkpJS5vIQCQkJ5OXlkZGRQWpqKjExMaVmWvZsk5KSUqV9xMbG1qzw9mBstrKZ0e0+QS+6Vgnv5VUMCKRzGSurt9VqlPs6ONGVnOlRV2d8HK9Ub9U7EARqvWt4xa0qqVZA2rt3L6eeemqF63/88UfuuOMOLrjgAgYMGMDevXvLbJOfn4/D4X8KdcntwsJC8vLyyqwHz6UpCgoKqrSPmrIEhxITUzbU5edbOXjQ0ui/OANN6Xq73QYWi4WoqFCCgxtvd2tkZGBNhlpC9Q4sqrf8WdUKSImJiSxZsqTC9W+//TZ5eXncdNNNFW4TFBRUJsSU3A4JCSE4OLjckFNQUEBISEiV9lFTLsNBRkZOmeWFhQW43W5cLrNRzS9hGJ6Q4HK5A64Fqbx6u1wmbrebw4dzyctzNVwB64jVaiEyMoSsrDxcrsbzOq6M6q16B4JArXdUVIj3uqG1rVoByW630759+wrXL1q0iLS0NAYPHgwcvfbWVVddxbnnnsuDDz5I06ZNSUtL87tfWloaoaGhREREkJSURGZmJoWFhX6tRGlpaSQmJgJUuo+aMm2OcgOQy9U400NJOAikcASV17uxBeHSXC53o65fRVTvwKJ6B4a6/P6q1dj12muvsXjxYj788EM+/PBDnn/+eQCmT5/OzTffDMCAAQNYuXKl3/2WL19Ov379sFgs9O/fH7fb7R2sDbBz505SU1MZOHBglfZRYzqLrd45nU7eeecN7+0XX3yO8847q9aPU1f7FRGRxqlWA1Lz5s1p3bq191+zZp4rvCcmJhIXFwfAhAkTWL9+PTNnzmT79u0sXLiQzz//nIkTJ3q3PeOMM5g2bRorVqxg/fr1TJ48mUGDBtGnT58q7aPGNIt2vfvPfz5n7twnG7oYIiIifup9dG7Hjh2ZN28e3333Heeeey7vvvsuM2bM8Dtt/6GHHiI5OZkbb7yRK6+8knbt2jFnzpxq7aNGdJp/vdOlAEVE5HhUZxNFArRo0YLffvutzPIRI0YwYsSIcu7hERoayvTp05k+fXqF21S2jxqpZguSaZrgrPlZc3+KzYFRg/Mbly37kQUL5vP77zsICQnlpJOGceONt7Jt2xZuvfUGHnzwMebPn0tqaio9evTk7rvv5623XuPzzxdjs9k5//wLufTSK737++yzT3n77TfYs2c3sbGxnHnmOUyYcDlWqxWA1NQUnnvuGVavXklubg69evXh+utvpkOHjixZ8gmPPPIAAMOGDWDOnPne/b7++su8//6/OXz4MN279+DOO++mZctWAGRnZ/PMM7P54YdvKSoqonPnrlx//SS6dOnmvf9HHy3izTdf5cCBAwwcOIimTZvV6GEWEZHAVKcB6YRTjYBkmia5Hz+MO3VbHRaoYtbEjoSc/c9qhaTMzEzuvvsObrzxVk46aRhpaalMn34f8+bNZsyYv+JyuXj11YXcd990nE4nd9xxC5dddhFnnnkOzz//Cl9++RkvvPAsw4adTPv2Hfj3v99k/vynufHGWxk4cDAbN/7KrFn/4vDhw9x8823k5uZw3XVX0qxZcx577AnsdgcLFz7PjTdexcsvv8Wpp/6F7Oxs5sx5go8++pzIyCjWrl1DSsp+fvllHTNmzKaoqJCHHrqXxx57iGeeeQHTNLnjjkk4HMH8619PER4ezuefL+a6667kuedeolOnLvznP58za9a/uPnm2xkwYBDff/8tzz8/j4SExDp8RkREpDEJzAlwKlLNC9UanFgTSB44kEphYSGJiUkkJTWlV68+zJz5FH/72wXebSZOvJYuXbrRo0cv+vcfSEhICNdfP4lWrVozYcJlAOzYsQ3TNHn99VcYN+7vjBt3Pi1btuK0007nyiuv5YMP3iU7O5svvviMw4czeeihf9GtWw86duzE/fdPJygomEWL/k1QUDDh4eEAxMXFY7fbAbDZbNx770N06NCRrl27c84549i8eSMAa9as4tdff+Ghhx6le/cetG7dhmuuuYHu3Xvy7rtvA/Dee+8wevQYxo07n1atWnPxxZcxdOjwenykRUTkRKcWJB9GNc5iMwyDkLP/eUJ1sXXs2JnRo09jypRbiYuLZ+DAwQwfPoKhQ09m/fqfAWjRoqV3+5CQEJo2beY9TlCQ5/EpKioiMzOD9PRD9OrVx+8Yffv2w+l0smvX72zfvo2WLVsTExPjXR8UFEy3bt3Zvn17heWMjY0jLCzcezsiItI7SeiWLZsxTZO//e1Mv/sUFhZ6t9mxYxujR5/mt75Hj15s3bqlKg+TiIiIApKfao5BMgyj2q1ODe3++x/miiuuYvny/7Fq1Qruv38avXr18Y4rstn8XxIVhbCKBle73abPfiraxo3NZq2wjMeaqsHtdhMWFsaLL75eZl1JCxQYmKb/PCCl6yUiInIs6mLz5WjcU7Rv2PArc+Y8QatWbfj73y9ixozZ3H33faxZs4qMjIxq7Ss2No7Y2Dhvy1OJdevWYrfbad68Be3bd2TPnl1kZKR71xcUFLB58ybatGkHVBzAKtKuXQdycnIoKiqiRYuW3n9vvPEKS5d+B0DHjp1Yv36d3/02b95UreOIiEhgU0DyYTTy0/zDwsJYtOhd5s2bw969e9ixYxtfffUlLVq0Ijo6utr7+8c/JrBo0b/54IP32Lt3D19++TkLFz7P2Wf/H+Hh4fzlL2OJiormnnumsmnTBrZt28qDD04jLy+Pc84ZBxy9NMzmzZsoKMiv9JiDByfTsWMn7rvvLn76aTV79+5h7txZLFnyiTd0XXzxZXz//be8+ear7Nmzm/fee5v//vfratdPREQCl/odfARFRDd0EepUmzZtefjhGbz00gt88MG7WCwWBgwYxBNPzCE1NaXa+/vHPy7G4bDzzjtvMnv2TBISEhk//lIuumgCAOHh4cyd+xxPP/0UN998PQC9evXm2WdfpFmz5gD06zeQbt16cN11V3DPPQ9Vekyr1cqTT85j3rzZ3HvvVPLy8mjTph0PPzyD/v09M62fdNIw7rtvOgsXPs+CBfPp3r0nF154Mf/5z+fVrqOIiAQmw9RMfQAU5OWSm1/+NbiKigo5dGg/cXFNsdsd5dz7xGWzWQLquj0lyqt3Y36ewVPnmJgwMjJyAuo5V71V70AQqPWOjQ3Daq2bzjB1sRULCglt6CKIiIjIcUIBSURERKQUBSQRERGRUhSQREREREpRQBIREREpRQGpGnTCX+Om51dEREooIFWB1eq5LEZhYUEDl0TqUsnza7VqejARkUCnb4IqsFishISEk53tuRyHwxFU7UtkHK/cbgOXK/BaTnzrbZomhYUFZGdnEBISfsxrwYmISGBQQKqiyMhYAG9IaiwsFgtud+BMKlaivHqHhIR7n2cREQlsCkhVZBgGUVFxRETE4HI5G7o4tcJqNYiKCuXw4dyAakUqr95Wq00tRyIi4qWAVE0WiwWLpXFchsJmsxAcHExeniugpqYP1HqLiEjV6SeziIiISCkKSCIiIiKlKCCJiIiIlGKYmh3Py+UKvPEoVqtF9Q4gqndgUb0DSyDW22Ix6mzaHQUkERERkVLUxSYiIiJSigKSiIiISCkKSCIiIiKlKCCJiIiIlKKAJCIiIlKKApKIiIhIKQpIIiIiIqUoIImIiIiUooAkIiIiUooCkoiIiEgpCkgiIiIipSggiYiIiJSigCQiIiJSSkAHJLfbzZw5cxg+fDh9+vThqquuYs+ePQ1drFqXmppK586dy/xbtGgRAJs2beLiiy+mT58+jBo1ildffbWBS/znPffcc0yYMMFvWWX1bAyvh/LqPW3atDLP/ahRo7zrT9R6Z2Zmcu+99zJixAj69evHP/7xD1avXu1dv2zZMsaNG0fv3r0ZO3Ysixcv9rt/QUEBDzzwAMnJyfTt25fbbruN9PT0+q5GtVVW78svv7zM8+37mjhR633o0CHuuOMOhgwZQt++fbn66qvZvn27d31jfX9XVu/G+v72tXPnTvr27ev9zoJ6er7NADZ37lxz8ODB5rfffmtu2rTJvOKKK8wxY8aYBQUFDV20WvXf//7X7Nmzp5mammqmpaV5/+Xl5Znp6enm4MGDzbvuusvctm2b+d5775k9e/Y033vvvYYudo29/vrrZpcuXcyLL77Yu6wq9TzRXw/l1ds0TfO8884zZ82a5ffcHzp0yLv+RK335Zdfbp555pnmqlWrzB07dpgPPPCA2atXL3P79u3mtm3bzJ49e5qzZs0yt23bZi5YsMDs1q2b+b///c97/6lTp5qjR482V61aZa5bt84899xzzfHjxzdgjarmWPU2TdNMTk4233zzTb/nOyMjw3v/E7XeF1xwgXn++eeb69atM7dt22bedNNN5rBhw8zc3NxG/f4+Vr1Ns/G+v0sUFhaa48aNMzt16mS+//77pmnW3+d5wAakgoICs2/fvuYbb7zhXXb48GGzV69e5ieffNKAJat9zz//vHnWWWeVu27+/PnmsGHDzKKiIu+yJ554whwzZkx9Fa/WpKSkmNdcc43Zp08fc+zYsX5BobJ6nsivh2PV2+12m3369DG//PLLcu97otb7999/Nzt16mSuXr3au8ztdpujR482n3rqKfOee+4xzzvvPL/7TJ482bziiitM0/Q8Zl26dDH/+9//etfv2LHD7NSpk/nTTz/VTyVqoLJ6Hzx40OzUqZO5YcOGcu9/otY7MzPTnDx5svnbb795l23atMns1KmTuW7dukb7/q6s3o31/e3riSeeMC+55BK/gFRfz3fAdrFt3ryZnJwckpOTvcsiIyPp1q0bq1atasCS1b7ffvuN9u3bl7tu9erVDBo0CJvN5l02ZMgQfv/9dw4ePFhfRawVGzZswG638/HHH9O7d2+/dZXV80R+PRyr3rt37yY3N5d27dqVe98Ttd4xMTE8//zz9OzZ07vMMAwMwyArK4vVq1f71Qk8z/eaNWswTZM1a9Z4l5Vo27YtiYmJJ3S9f/vtNwzDoG3btuXe/0Std1RUFE888QSdOnUCID09nZdffpmkpCQ6dOjQaN/fldW7sb6/S6xatYp33nmHxx57zG95fT3ftso3aZxSUlIAaNq0qd/yhIQE77rGYsuWLcTExDB+/Hh27txJ69atue666xgxYgQpKSneN1+JhIQEAPbv3098fHxDFLlGRo0a5df37quyep7Ir4dj1XvLli0AvPbaa3z//fdYLBZGjBjBrbfeSkRExAlb78jISE4++WS/ZV988QW7du3in//8Jx988AFJSUl+6xMSEsjLyyMjI4PU1FRiYmIICgoqs82JXO8tW7YQERHBgw8+yI8//khoaChjx47l+uuvx+FwnLD19nXPPffw73//G4fDwbPPPktoaGijfn+XKK/ejfX9DZCVlcWdd97JtGnTypS/vp7vgG1BysvLA8DhcPgtDwoKoqCgoCGKVCecTic7duzg8OHD3HTTTTz//PP06dOHq6++mmXLlpGfn1/uYwA0qsehsno21tfDli1bsFgsJCQkMH/+fKZOncrSpUu5/vrrcbvdjabeP/30E3fddRdjxoxh5MiR5T7fJbcLCwvJy8srsx5O/Hpv2bKFgoICevXqxYIFC7juuut49913mTZtGkCjqPell17K+++/z5lnnskNN9zAhg0bAuL9XV69G/P7+/7776dv376cddZZZdbV1/MdsC1IwcHBgOfDsuRv8Dy4ISEhDVWsWmez2VixYgVWq9Vbzx49erB161ZefPFFgoODKSws9LtPyQsoNDS03stbVyqrZ2N9PVx33XVcdNFFxMTEANCpUyeaNGnC3//+d3755ZdGUe+vvvqK22+/nX79+jFz5kzA80FY+vkuuR0SElLu6wFO/Ho/+OCDTJkyhaioKMDzfNvtdm699VbuvPPORlHvDh06APDwww+zbt06Xn/99YB4f5dX74cffrhRvr8//PBDVq9ezSeffFLu+vp6vgO2Bamk6S0tLc1veVpaGomJiQ1RpDoTFhbm9yIB6NixI6mpqSQlJZX7GACN6nGorJ6N9fVgsVi8H54lOnbsCHiaqU/0er/++uvcdNNNnHLKKcyfP9/7K7Jp06bl1ik0NJSIiAiSkpLIzMws8yF7otfbZrN5w1EJ3+f7RK13eno6ixcvxul0epdZLBY6dOhAWlpao31/V1bvxvr+fv/99zl06BAjR46kb9++9O3bF4D77ruPiRMn1tvzHbABqUuXLoSHh7NixQrvsqysLDZu3MjAgQMbsGS1a+vWrfTr18+vngC//vorHTp0YODAgaxZswaXy+Vdt3z5ctq2bUtcXFx9F7fOVFbPxvp6uPPOO7nsssv8lv3yyy+A5xfpiVzvN998k4ceeojx48cza9Ysv+b0AQMGsHLlSr/tly9fTr9+/bBYLPTv3x+32+0dtAyeuVZSU1NP6HpPmDCBu+66y2/7X375BbvdTps2bU7Yeh88eJDJkyezbNky77KioiI2btxI+/btG+37u7J6N9b398yZM1myZAkffvih9x/ApEmTePjhh+vv+a6dE/FOTLNmzTIHDRpkfvXVV37zJBQWFjZ00WqNy+Uy//a3v5mnn366uWrVKnPbtm3mI488Yvbo0cP87bffzIMHD5oDBw40p0yZYm7dutV8//33zZ49e5qLFi1q6KL/KVOmTPE73b0q9WwMr4fS9f7qq6/MTp06mXPnzjV37dpl/ve//zVHjRplTp482bvNiVjvHTt2mN27dzdvuOEGv/lf0tLSzKysLHPLli1m9+7dzRkzZpjbtm0zX3zxxTLzIE2ePNkcNWqUuXz5cu98QKXnkDreVFbv1157zezatav55ptvmrt37zYXL15sDh482Jw1a5Z3HydivU3TNCdOnGiOGTPGXLlypfnbb7+ZkydPNgcOHGju27evUb+/j1Xvxvr+Lo/vaf719XwHdEByOp3m448/bg4ZMsTs06ePedVVV5l79uxp6GLVugMHDphTp041hw4davbs2dO84IILzFWrVnnXr1u3zvz73/9u9ujRwzzllFPM1157rQFLWztKBwXTrLyejeH1UF69lyxZYp577rlmr169zKFDh5qPPfaYmZ+f711/Itb72WefNTt16lTuvylTppimaZrfffedeeaZZ5o9evQwx44day5evNhvHzk5Oebdd99tDhgwwBwwYIA5efJkMz09vSGqU2VVqffrr79u/vWvf/W+zp999lnT5XJ593Ei1ts0TTMrK8u87777zKFDh5q9evUyr7jiCnPLli3e9Y31/V1ZvRvj+7s8vgHJNOvn+TZM0zRrq1lMREREpDEI2DFIIiIiIhVRQBIREREpRQFJREREpBQFJBEREZFSFJBERERESlFAEhERESlFAUlERESkFAUkERERkVIUkESkUdi7dy+dO3dm0aJFf3pfU6dOZdSoUbVQKhE5UdkaugAiIrUhISGBd955h1atWjV0UUSkEVBAEpFGweFw0KdPn4Yuhog0EupiE5F68e6773LGGWfQo0cPRo4cydy5c3G5XICnS2vChAm89957nHLKKfTt25dLL72UzZs3e+/vdrt58sknGTVqFD169GDUqFE88cQTFBUVAeV3sf3+++9MmjSJoUOH0qdPHyZMmMCaNWv8ynX48GHuuusuBg0axMCBA5kxYwZut7tM+b/66ivGjRtHz549GTp0KNOnTyc3N9e7Pj8/n/vvv58RI0bQo0cPxo4dy4svvlirj6GI1B+1IIlInXvuued48sknufjii7nrrrvYtGkTc+fOZf/+/TzyyCMAbNq0iR07djB58mSioqKYM2cOF198MUuWLCEhIYEXXniBt956iylTptCyZUvWrVvHk08+id1uZ9KkSWWOuW3bNv7+97/Tpk0bpk2bht1u59VXX+XSSy9l4cKFDBo0CLfbzcSJE9m3bx9TpkwhOjqaBQsW8Msvv5CQkODd1yeffMLtt9/OWWedxS233MK+fft48skn2bZtGy+99BKGYfDII4+wdOlSpkyZQnx8PN9//z2PP/440dHR/O1vf6u3x1pEaocCkojUqSNHjjBv3jwuuOACpk2bBsCwYcOIjo5m2rRpXH755d7t5s+fz4ABAwDo1asXo0eP5tVXX+X2229n5cqV9OjRwxs2Bg0aREhICBEREeUe9+mnn8bhcPDqq68SHh4OwMiRIznzzDN5/PHHee+99/j+++9Zv349L7zwAiNGjAAgOTnZb4C2aZrMnDmT4cOHM3PmTO/yNm3acNlll/Hdd98xcuRIVq5cydChQznjjDMAGDx4MKGhocTFxdXmwyki9URdbCJSp9auXUt+fj6jRo3C6XR6/5WEkB9//BGAFi1aeMMReAZd9+3bl1WrVgGewPHjjz9y0UUXsWDBArZt28bFF1/MOeecU+5xV65cySmnnOINRwA2m40zzjiDX3/9lZycHFavXo3dbmf48OHebUJDQzn55JO9t3fs2EFKSkqZ8g8cOJDw8HBv+QcPHsy///1vrrrqKl5//XX27NnDDTfcwMiRI2vngRSReqUWJBGpU5mZmQBcffXV5a5PS0sDIDExscy6uLg4NmzYAMDEiRMJCwvj/fffZ+bMmcyYMYOOHTsybdo0hgwZUua+hw8fJj4+vszy+Ph4TNMkOzubw4cPEx0djWEYfts0adKkTPkfeOABHnjggQrLf/fdd5OUlMTHH3/MQw89xEMPPUTfvn25//776dKlS7l1F5HjlwKSiNSpyMhIAGbOnEmbNm3KrI+Pj2f27NlkZGSUWXfw4EFvF5XFYmH8+PGMHz+eQ4cO8d133zF//nxuuukmbyuOr6ioKA4ePFhm+YEDBwCIiYkhJiaGjIwMXC4XVqvVu01JKPIt/5133smgQYPKPQ54zqK77rrruO666/jjjz/49ttvmTdvHrfddhuLFy+u6OERkeOUuthEpE717t0bu91OamoqPXv29P6z2WzMmjWLvXv3Ap4zzrZv3+69X2pqKmvXriU5ORmACy+8kOnTpwOelqVx48Yxfvx4srKyyM7OLnPcgQMH8u233/qtc7lcLF68mJ49e+JwOEhOTsbpdPLVV195tyksLPQLXO3atSMuLo69e/f6lT8xMZEnnniCjRs3kp+fz2mnncbChQsBaNasGePHj+eMM87gjz/+qMVHU0Tqi1qQRKROxcTEMHHiRGbPnk12djaDBw8mNTWV2bNnYxiGt/vJNE2uvfZabr31VqxWK08//TRRUVFMmDAB8ASehQsXEh8fT9++fUlNTeWll15i0KBBxMbG+p1yD3DjjTfy/fffc8kll3D11Vdjt9u9Y4MWLFgAeAZkDxs2jGnTpnHo0CGaN2/Oq6++Snp6urflymq1cuutt3LvvfditVo55ZRTyMrKYt68eaSmptK9e3eCg4Pp3r07Tz/9NHa7nc6dO7Nz504++OADTjvttHp8tEWkthimaZoNXQgRafzeeOMN3nzzTXbt2kVUVBTJyclMnjyZZs2aMXXqVFauXMlVV13FM888Q15eHieddBJTpkyhRYsWADidTp599lk+/vhjUlJSiIiIYNSoUdx2223ExMSwd+9eTj31VB599FHGjRsHeKYOmDVrFqtXr8YwDHr16sWNN97oNxg8Ly+PmTNnsnjxYgoKCjj99NMJDQ3l66+/5ptvvvFut2TJEhYsWMDWrVsJDQ2lX79+3HLLLXTu3BmA7OxsnnrqKb7++msOHDhAXFwcp59+OjfffDPBwcH1+EiLSG1QQBKRBlcSkHwDiYhIQ9IYJBEREZFSFJBERERESlEXm4iIiEgpakESERERKUUBSURERKQUBSQRERGRUhSQREREREpRQBIREREpRQFJREREpBQFJBEREZFSFJBERERESvl/X9MauZKCeukAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], title=f\"training curve of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('gsc': conda)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "216dab6b21526179d387c06b08cb2654f2959273fc1353fb08296303e34d0db1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
